@amazon/vinyl 1.0.0

package/dist/types/current/streaming/buffering/MediaSourceController.js

@@ -0,0 +1,116 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createDisposer, DomEventHost, ErrorLevel, ErrorOrigin, EventHostImpl, logDebug, ReportableError, toJson, toLowerCase, } from '@amazon/vinyl-util';
+export class MediaSourceControllerImpl extends EventHostImpl {
+    get [Symbol.toStringTag]() {
+        return 'MediaSourceControllerImpl';
+    }
+    sourceBufferCount = 0;
+    mediaSource;
+    disposer = createDisposer();
+    contentTypes = null;
+    constructor(deps) {
+        super();
+        this.mediaSource = deps.mediaSourceFactory();
+        this.initializeEvents();
+        this.disposer.add(deps.contentTypesValue.onData((value) => {
+            this.contentTypes = null;
+            value
+                .then((contentTypes) => {
+                this.contentTypes = contentTypes;
+                this.checkReady();
+            })
+                .catch((error) => {
+                this.dispatch('error', {
+                    target: this,
+                    error: error,
+                });
+            });
+        }));
+    }
+    initializeEvents() {
+        const domEvents = new DomEventHost(this.mediaSource);
+        // Re-dispatch html media element events exposed on the playback controller as empty events.
+        for (const key of [
+            'sourceClose',
+            'sourceOpen',
+            'sourceEnded',
+        ]) {
+            domEvents.on(toLowerCase(key), () => this.dispatch(key, {}));
+        }
+    }
+    get duration() {
+        return this.mediaSource.duration;
+    }
+    set duration(value) {
+        this.mediaSource.duration = value;
+    }
+    get readyState() {
+        return this.mediaSource.readyState;
+    }
+    createSourceBuffer(contentType, mimeType) {
+        const mediaSource = this.mediaSource;
+        logDebug(this, 'create source buffer', contentType, mimeType, mediaSource.readyState, 'sourceBufferCount:', this.sourceBufferCount);
+        let sourceBuffer;
+        try {
+            sourceBuffer = mediaSource.addSourceBuffer(mimeType);
+        }
+        catch (error) {
+            throw new MediaSourceError('error creating source buffer', error);
+        }
+        sourceBuffer.mode = 'sequence';
+        ++this.sourceBufferCount;
+        this.checkReady();
+        const dispose = () => {
+            logDebug(this, 'removing source buffer from media source', mediaSource.readyState);
+            if (mediaSource.readyState !== 'closed') {
+                mediaSource.removeSourceBuffer(sourceBuffer);
+            }
+            --this.sourceBufferCount;
+        };
+        return {
+            value: sourceBuffer,
+            dispose,
+        };
+    }
+    /**
+     * Emits a 'readyToAppend' event if all source buffers have been created.
+     */
+    checkReady = () => {
+        if (this.readyToAppend)
+            this.dispatch('readyToAppend', {});
+    };
+    endOfStream(error) {
+        logDebug(this, 'endOfStream, error:', error);
+        this.mediaSource.endOfStream(error);
+    }
+    createUrl() {
+        return URL.createObjectURL(this.mediaSource);
+    }
+    get readyToAppend() {
+        return this.contentTypes?.size === this.sourceBufferCount;
+    }
+    dispose() {
+        super.dispose();
+        this.disposer.dispose();
+    }
+}
+export class MediaSourceError extends ReportableError {
+    reason;
+    get [Symbol.toStringTag]() {
+        return 'MediaSourceError';
+    }
+    constructor(message, reason) {
+        super(message, ErrorOrigin.INTERNAL, ErrorLevel.FATAL);
+        this.reason = reason;
+        Object.setPrototypeOf(this, MediaSourceError.prototype);
+    }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            reason: toJson(this.reason),
+        };
+    }
+}

package/dist/types/current/streaming/buffering/SourceBufferController.d.ts

@@ -0,0 +1,91 @@
+import { type Disposable, type LogTarget, type ReadonlyRanges, type Task } from '@amazon/vinyl-util';
+import type { MediaSourceController } from './MediaSourceController';
+import type { ContentType } from '../../streaming/MediaQualityMetadata';
+export declare const APPEND_WINDOW_START_OFFSET = 0.05;
+export declare const APPEND_WINDOW_END_OFFSET = 0.01;
+export declare const READY_TO_APPEND_TIMEOUT = 30;
+export type SourceBufferControllerFactory = () => SourceBufferController;
+export interface SourceBufferController extends Disposable {
+    readonly buffered: ReadonlyRanges;
+    /**
+     * Returns true if an operation is currently running.
+     */
+    isBusy(): boolean;
+    /**
+     * Enqueues an operation.
+     * Guaranteed to be invoked when the source buffer is not updating.
+     */
+    enqueue<T = void>(task: Task<T>): Promise<T>;
+    /**
+     * Enqueues appending an initialization segment, reinitializing the decoder.
+     */
+    appendInit(data: ArrayBuffer, mimeType: string): Promise<void>;
+    /**
+     * Enqueues appending a media segment.
+     * An `appendInit` call must precede appending media segments.
+     * A promise is returned that will resolve when the task is complete.
+     */
+    append(data: ArrayBuffer): Promise<void>;
+    /**
+     * Sets the timestampOffset on the backing source buffer.
+     */
+    setTimestampOffset(timestampOffset: number): Promise<void>;
+    /**
+     * Sets the append window on the backing source buffer.
+     * Keyframes outside this range will be discarded.
+     */
+    setAppendWindow(appendWindowStart?: number, appendWindowEnd?: number): Promise<void>;
+    /**
+     * Removes media segments within a specific time range from the SourceBuffer.
+     */
+    remove(startTime: number, endTime: number): Promise<void>;
+    /**
+     * Aborts any pending buffers and clears all buffered ranges.
+     */
+    clear(): Promise<void>;
+}
+export interface SourceBufferControllerImplDeps {
+    /**
+     * Produces the source buffer for appending.
+     */
+    readonly mediaSourceController: MediaSourceController;
+}
+/**
+ * The SourceBufferController manages a single source buffer. It provides queued commands for appending and clearing
+ * data.
+ */
+export declare class SourceBufferControllerImpl implements LogTarget, SourceBufferController, Disposable {
+    readonly contentType: ContentType;
+    get [Symbol.toStringTag](): string;
+    private sourceBufferRef;
+    private mimeType;
+    private queue;
+    readonly logPrefix: string;
+    private readonly mediaSourceController;
+    constructor(deps: SourceBufferControllerImplDeps, contentType: ContentType);
+    private get sourceBuffer();
+    private _buffered;
+    get buffered(): ReadonlyRanges;
+    /**
+     * Clears the cached buffered ranges. They will be recreated next access.
+     */
+    private clearBufferedCache;
+    isBusy(): boolean;
+    enqueue<T = void>(task: Task<T>): Promise<T>;
+    appendInit(data: ArrayBuffer, mimeType: string): Promise<void>;
+    append(data: ArrayBuffer): Promise<void>;
+    setTimestampOffset(timestampOffset: number): Promise<void>;
+    setAppendWindow(appendWindowStart?: number, appendWindowEnd?: number): Promise<void>;
+    remove(startTime: number, endTime: number): Promise<void>;
+    /**
+     * Returns a promise that resolves when the source buffer is no longer updating.
+     * @private
+     */
+    private nextIdle;
+    clear(): Promise<void>;
+    /**
+     * Aborts any pending operations and disposes the backed SourceBuffer.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=SourceBufferController.d.ts.map

package/dist/types/current/streaming/buffering/SourceBufferController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SourceBufferController.d.ts","sourceRoot":"","sources":["../../../../../src/streaming/buffering/SourceBufferController.ts"],"names":[],"mappings":"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"}

package/dist/types/current/streaming/buffering/SourceBufferController.js

@@ -0,0 +1,150 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createLogPrefix, createTaskQueue, createTimeRangesReader, emptyRanges, ErrorOrigin, IllegalStateError, logDebug, nextEventAsPromise, } from '@amazon/vinyl-util';
+import { nextSourceBufferIdle } from '../../util/media/sourceBuffer';
+import { SourceBufferError } from './error/SourceBufferError';
+// Prevents unintentionally dropped keyframes
+export const APPEND_WINDOW_START_OFFSET = 0.05;
+export const APPEND_WINDOW_END_OFFSET = 0.01;
+// The number of seconds before aborting the wait for media source controller's readyToAppend event.
+export const READY_TO_APPEND_TIMEOUT = 30;
+/**
+ * The SourceBufferController manages a single source buffer. It provides queued commands for appending and clearing
+ * data.
+ */
+export class SourceBufferControllerImpl {
+    contentType;
+    get [Symbol.toStringTag]() {
+        return 'SourceBufferController';
+    }
+    sourceBufferRef = null;
+    mimeType = null;
+    queue = createTaskQueue();
+    logPrefix = createLogPrefix(this);
+    mediaSourceController;
+    constructor(deps, contentType) {
+        this.contentType = contentType;
+        logDebug(this, 'constructed, contentType:', contentType);
+        this.mediaSourceController = deps.mediaSourceController;
+    }
+    get sourceBuffer() {
+        return this.sourceBufferRef && this.sourceBufferRef.value;
+    }
+    _buffered = null;
+    get buffered() {
+        if (this._buffered == null) {
+            if (!this.sourceBuffer)
+                this._buffered = emptyRanges;
+            else
+                this._buffered = createTimeRangesReader(this.sourceBuffer.buffered);
+        }
+        return this._buffered;
+    }
+    /**
+     * Clears the cached buffered ranges. They will be recreated next access.
+     */
+    clearBufferedCache = () => {
+        this._buffered = null;
+    };
+    isBusy() {
+        return this.queue.running > 0;
+    }
+    enqueue(task) {
+        return this.queue.enqueue(task);
+    }
+    async appendInit(data, mimeType) {
+        return this.queue.enqueue(async (abort) => {
+            if (this.mimeType !== mimeType) {
+                if (this.sourceBuffer && 'changeType' in this.sourceBuffer) {
+                    // There is an existing source buffer and its mime type can be changed.
+                    logDebug(this, 'changeType', mimeType);
+                    this.sourceBuffer.changeType(mimeType);
+                }
+                else {
+                    // There is either no existing source buffer or a new buffer must be created
+                    // with the new mime type.
+                    this.sourceBufferRef?.dispose();
+                    const newSourceBufferRef = this.mediaSourceController.createSourceBuffer(this.contentType, mimeType);
+                    // Do not append to the source buffer until all streams have been created:
+                    if (!this.mediaSourceController.readyToAppend)
+                        await nextEventAsPromise(this.mediaSourceController, 'readyToAppend', { timeout: READY_TO_APPEND_TIMEOUT, abort }).catch((error) => {
+                            // The readyToAppend was aborted or timed out, dispose the source buffer
+                            newSourceBufferRef.dispose();
+                            throw error;
+                        });
+                    this.sourceBufferRef = newSourceBufferRef;
+                }
+                this.mimeType = mimeType;
+            }
+            const sourceBuffer = this.sourceBuffer;
+            logDebug(this, `appending init ${data.byteLength} bytes`);
+            sourceBuffer.appendBuffer(data);
+            await this.nextIdle();
+            logDebug(this, 'appended init');
+        });
+    }
+    async append(data) {
+        return this.queue.enqueue(async () => {
+            logDebug(this, `appending ${data.byteLength} bytes`);
+            const sourceBuffer = this.sourceBuffer;
+            if (!sourceBuffer)
+                throw new SourceBufferError('media segment provided before init segment', ErrorOrigin.INTERNAL);
+            sourceBuffer.appendBuffer(data);
+            await this.nextIdle();
+            logDebug(this, 'appended', this.buffered);
+        });
+    }
+    setTimestampOffset(timestampOffset) {
+        return this.queue.enqueue(() => {
+            const sourceBuffer = this.sourceBuffer;
+            if (!sourceBuffer)
+                throw new IllegalStateError('source buffer must be initialized before setting timestamp offset');
+            logDebug(this, 'timestampOffset:', timestampOffset.toFixed(4));
+            sourceBuffer.timestampOffset = timestampOffset;
+        });
+    }
+    setAppendWindow(appendWindowStart = 0, appendWindowEnd = Number.POSITIVE_INFINITY) {
+        return this.queue.enqueue(() => {
+            const sourceBuffer = this.sourceBuffer;
+            if (!sourceBuffer)
+                throw new IllegalStateError('source buffer must be initialized before setting append window');
+            const finalAppendWindowStart = Math.max(0, appendWindowStart - APPEND_WINDOW_START_OFFSET);
+            const finalAppendWindowEnd = appendWindowEnd + APPEND_WINDOW_END_OFFSET;
+            logDebug(this, 'appendWindow:', finalAppendWindowStart.toFixed(4), finalAppendWindowEnd.toFixed(4));
+            // start may not be greater than end, even temporarily.
+            // Avoids the error: "Failed to set the 'appendWindow___' property"
+            sourceBuffer.appendWindowStart = 0;
+            sourceBuffer.appendWindowEnd = finalAppendWindowEnd;
+            sourceBuffer.appendWindowStart = finalAppendWindowStart;
+        });
+    }
+    remove(startTime, endTime) {
+        return this.queue.enqueue(async () => {
+            if (endTime > startTime) {
+                logDebug(this, `removing range: ${startTime}-${endTime}`);
+                this.sourceBuffer?.remove(startTime, endTime);
+                await this.nextIdle();
+                logDebug(this, 'removed, new buffered:', this.buffered);
+            }
+        });
+    }
+    /**
+     * Returns a promise that resolves when the source buffer is no longer updating.
+     * @private
+     */
+    nextIdle = () => nextSourceBufferIdle(this.sourceBuffer).finally(this.clearBufferedCache);
+    async clear() {
+        await this.remove(0, Number.POSITIVE_INFINITY);
+    }
+    /**
+     * Aborts any pending operations and disposes the backed SourceBuffer.
+     */
+    dispose() {
+        logDebug(this, 'dispose');
+        this.queue.abort();
+        this.sourceBufferRef?.dispose();
+        this.sourceBufferRef = null;
+    }
+}

package/dist/types/current/streaming/buffering/error/SourceBufferError.d.ts

@@ -0,0 +1,9 @@
+import { ReportableError } from '@amazon/vinyl-util';
+/**
+ * An error emitted from the SourceBuffer.
+ */
+export declare class SourceBufferError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message?: string, origin?: string);
+}
+//# sourceMappingURL=SourceBufferError.d.ts.map

package/dist/types/current/streaming/buffering/error/SourceBufferError.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SourceBufferError.d.ts","sourceRoot":"","sources":["../../../../../../src/streaming/buffering/error/SourceBufferError.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAEpD;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,eAAe;IAClD,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;gBAGG,OAAO,SAAuC,EAC9C,MAAM,SAAoB;CAKjC"}

package/dist/types/current/streaming/buffering/error/SourceBufferError.js

@@ -0,0 +1,18 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { ErrorOrigin } from '@amazon/vinyl-util';
+import { ReportableError } from '@amazon/vinyl-util';
+/**
+ * An error emitted from the SourceBuffer.
+ */
+export class SourceBufferError extends ReportableError {
+    get [Symbol.toStringTag]() {
+        return 'SourceBufferError';
+    }
+    constructor(message = `A SourceBuffer error has occurred.`, origin = ErrorOrigin.MEDIA) {
+        super(message, origin);
+        Object.setPrototypeOf(this, SourceBufferError.prototype);
+    }
+}

package/dist/types/current/streaming/createDefaultMediaTimelineTransformer.d.ts

@@ -0,0 +1,18 @@
+import type { ObservableValue } from '@amazon/vinyl-observable';
+import type { Capabilities } from '../client/Capabilities';
+import type { DrmController } from '../drm/DrmController';
+import type { MediaTimeline } from '../streaming/MediaTimeline';
+export interface DefaultMediaTimelineTransformerDeps {
+    readonly capabilities: Capabilities;
+    readonly drmController: DrmController;
+    readonly mediaTimeline: ObservableValue<Promise<MediaTimeline>>;
+    readonly options: ObservableValue<{
+        readonly preferredAudioLanguage: string | null;
+    }>;
+}
+/**
+ * The default media timeline transformer filters out unplayable qualities
+ * and applies language preferences. Shared by Dash and HLS.
+ */
+export declare function createDefaultMediaTimelineTransformer(deps: DefaultMediaTimelineTransformerDeps): ObservableValue<Promise<MediaTimeline>>;
+//# sourceMappingURL=createDefaultMediaTimelineTransformer.d.ts.map

package/dist/types/current/streaming/createDefaultMediaTimelineTransformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createDefaultMediaTimelineTransformer.d.ts","sourceRoot":"","sources":["../../../../src/streaming/createDefaultMediaTimelineTransformer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AAoB9D,MAAM,WAAW,mCAAmC;IAChD,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAA;IACnC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAA;IACrC,QAAQ,CAAC,aAAa,EAAE,eAAe,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAA;IAC/D,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;QAC9B,QAAQ,CAAC,sBAAsB,EAAE,MAAM,GAAG,IAAI,CAAA;KACjD,CAAC,CAAA;CACL;AAED;;;GAGG;AACH,wBAAgB,qCAAqC,CACjD,IAAI,EAAE,mCAAmC,GAC1C,eAAe,CAAC,OAAO,CAAC,aAAa,CAAC,CAAC,CAqCzC"}

package/dist/types/current/streaming/createDefaultMediaTimelineTransformer.js

@@ -0,0 +1,30 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { combineData } from '@amazon/vinyl-observable';
+import { filterTimelineQualities, filterTimelineQualitiesAsync, } from '../streaming/mediaTimelineFilter';
+import { createLanguageFilter } from '../streaming/mediaTimelineLanguageFilter';
+import { canPlayMimeType, throwMimeTypesUnsupported, } from '../track/filters/resourceTypeFilter';
+import { canPlayKeySystem, throwKeySystemsUnsupported, } from '../track/filters/keySystemFilter';
+import { supportsAudioSamplingRate, throwSamplingRatesUnsupported, } from '../track/filters/sampleRateFilter';
+import { throwLanguagesUnsupported } from '../track/filters/languageFilter';
+/**
+ * The default media timeline transformer filters out unplayable qualities
+ * and applies language preferences. Shared by Dash and HLS.
+ */
+export function createDefaultMediaTimelineTransformer(deps) {
+    async function transformTimeline(timeline) {
+        let t = filterTimelineQualities((quality) => canPlayMimeType(deps, quality), throwMimeTypesUnsupported, timeline);
+        t = await filterTimelineQualitiesAsync((quality) => canPlayKeySystem(deps, quality), throwKeySystemsUnsupported, t);
+        t = filterTimelineQualities((quality, index, array) => supportsAudioSamplingRate(deps, quality, index, array), throwSamplingRatesUnsupported, t);
+        t = filterTimelineQualities(createLanguageFilter(deps.options.value.preferredAudioLanguage, 'audio'), throwLanguagesUnsupported, t);
+        return t;
+    }
+    return combineData({
+        timeline: deps.mediaTimeline,
+        preferredAudioLanguage: deps.options.pick('preferredAudioLanguage'),
+    }).map(async ({ timeline }) => {
+        return transformTimeline(await timeline);
+    });
+}

package/dist/types/current/streaming/mediaTimelineFilter.d.ts

@@ -0,0 +1,18 @@
+import type { MediaTimeline } from '../streaming/MediaTimeline';
+import type { MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import type { FilterPredicate, FilterPredicateAsync, Maybe } from '@amazon/vinyl-util';
+/**
+ * Filters qualities in a MediaTimeline using a synchronous predicate.
+ * If filtering would remove all qualities from any period, throws via `throwError`.
+ */
+export declare function filterTimelineQualities(filter: Maybe<FilterPredicate<MediaQualityMetadata>>, throwError: () => never, timeline: MediaTimeline): MediaTimeline;
+/**
+ * Filters qualities in a MediaTimeline using an asynchronous predicate.
+ * If filtering would remove all qualities from any period, throws via `throwError`.
+ */
+export declare function filterTimelineQualitiesAsync(filter: FilterPredicateAsync<MediaQualityMetadata>, throwError: () => never, timeline: MediaTimeline): Promise<MediaTimeline>;
+/**
+ * Creates a language filter predicate for use with filterTimelineQualities.
+ */
+export { createLanguageFilter } from '../streaming/mediaTimelineLanguageFilter';
+//# sourceMappingURL=mediaTimelineFilter.d.ts.map

package/dist/types/current/streaming/mediaTimelineFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediaTimelineFilter.d.ts","sourceRoot":"","sources":["../../../../src/streaming/mediaTimelineFilter.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAGR,aAAa,EAChB,MAAM,2BAA2B,CAAA;AAClC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAA;AAC5E,OAAO,KAAK,EACR,eAAe,EACf,oBAAoB,EACpB,KAAK,EACR,MAAM,oBAAoB,CAAA;AAG3B;;;GAGG;AACH,wBAAgB,uBAAuB,CACnC,MAAM,EAAE,KAAK,CAAC,eAAe,CAAC,oBAAoB,CAAC,CAAC,EACpD,UAAU,EAAE,MAAM,KAAK,EACvB,QAAQ,EAAE,aAAa,GACxB,aAAa,CAqBf;AAED;;;GAGG;AACH,wBAAsB,4BAA4B,CAC9C,MAAM,EAAE,oBAAoB,CAAC,oBAAoB,CAAC,EAClD,UAAU,EAAE,MAAM,KAAK,EACvB,QAAQ,EAAE,aAAa,GACxB,OAAO,CAAC,aAAa,CAAC,CAyBxB;AAED;;GAEG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,yCAAyC,CAAA"}

package/dist/types/current/streaming/mediaTimelineFilter.js

@@ -0,0 +1,48 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { map, memoize } from '@amazon/vinyl-util';
+/**
+ * Filters qualities in a MediaTimeline using a synchronous predicate.
+ * If filtering would remove all qualities from any period, throws via `throwError`.
+ */
+export function filterTimelineQualities(filter, throwError, timeline) {
+    if (!filter)
+        return timeline;
+    const mapMetadataArray = memoize((qualities) => map(qualities, (q) => q.metadata), (qualities) => qualities, 1);
+    const periods = timeline.periods.map((period) => {
+        const filtered = period.qualities.filter((q, index) => filter(q.metadata, index, mapMetadataArray(period.qualities)));
+        return { ...period, qualities: filtered };
+    });
+    if (periods.some((p) => p.qualities.length === 0)) {
+        throwError();
+    }
+    return { ...timeline, periods };
+}
+/**
+ * Filters qualities in a MediaTimeline using an asynchronous predicate.
+ * If filtering would remove all qualities from any period, throws via `throwError`.
+ */
+export async function filterTimelineQualitiesAsync(filter, throwError, timeline) {
+    const mapMetadataArray = memoize((qualities) => map(qualities, (q) => q.metadata), (qualities) => qualities, 1);
+    const periods = [];
+    for (const period of timeline.periods) {
+        const filtered = [];
+        const metadataArray = mapMetadataArray(period.qualities);
+        for (let i = 0; i < period.qualities.length; i++) {
+            if (await filter(period.qualities[i].metadata, i, metadataArray)) {
+                filtered.push(period.qualities[i]);
+            }
+        }
+        periods.push({ ...period, qualities: filtered });
+    }
+    if (periods.some((p) => p.qualities.length === 0)) {
+        throwError();
+    }
+    return { ...timeline, periods };
+}
+/**
+ * Creates a language filter predicate for use with filterTimelineQualities.
+ */
+export { createLanguageFilter } from '../streaming/mediaTimelineLanguageFilter';

package/dist/types/current/streaming/mediaTimelineLanguageFilter.d.ts

@@ -0,0 +1,14 @@
+import type { MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import type { FilterPredicate } from '@amazon/vinyl-util';
+/**
+ * Creates a filter predicate that keeps qualities matching the preferred language.
+ * The best language match is computed per period (per unique array reference),
+ * so periods with different available languages are handled independently.
+ *
+ * Qualities not matching the content type or without a language tag are always kept.
+ *
+ * @param preferredLanguage BCP 47 language tag, or null to keep all.
+ * @param contentType Only filter qualities matching this content type (e.g. 'audio').
+ */
+export declare function createLanguageFilter(preferredLanguage: string | null, contentType: string): FilterPredicate<MediaQualityMetadata> | null;
+//# sourceMappingURL=mediaTimelineLanguageFilter.d.ts.map

package/dist/types/current/streaming/mediaTimelineLanguageFilter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediaTimelineLanguageFilter.d.ts","sourceRoot":"","sources":["../../../../src/streaming/mediaTimelineLanguageFilter.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAA;AAC5E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AAOzD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAChC,iBAAiB,EAAE,MAAM,GAAG,IAAI,EAChC,WAAW,EAAE,MAAM,GACpB,eAAe,CAAC,oBAAoB,CAAC,GAAG,IAAI,CAyB9C"}

package/dist/types/current/streaming/mediaTimelineLanguageFilter.js

@@ -0,0 +1,36 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { memoize } from '@amazon/vinyl-util';
+import { findBestLanguageMatch, languageRelatedness, } from '../track/filters/languageFilter';
+/**
+ * Creates a filter predicate that keeps qualities matching the preferred language.
+ * The best language match is computed per period (per unique array reference),
+ * so periods with different available languages are handled independently.
+ *
+ * Qualities not matching the content type or without a language tag are always kept.
+ *
+ * @param preferredLanguage BCP 47 language tag, or null to keep all.
+ * @param contentType Only filter qualities matching this content type (e.g. 'audio').
+ */
+export function createLanguageFilter(preferredLanguage, contentType) {
+    if (!preferredLanguage)
+        return null;
+    // Finds the best language for the period by relevance.
+    // If no languages are related, the first language will be chosen.
+    const bestRelevanceForPeriod = memoize((array) => {
+        const langs = Array.from(array)
+            .filter((q) => q.contentType === contentType && q.lang)
+            .map((q) => q.lang);
+        return languageRelatedness(preferredLanguage, findBestLanguageMatch(preferredLanguage, langs));
+    }, (array) => array, 1);
+    return (quality, _index, array) => {
+        if (quality.contentType !== contentType)
+            return true;
+        if (!quality.lang)
+            return true;
+        const bestScore = bestRelevanceForPeriod(array);
+        return languageRelatedness(preferredLanguage, quality.lang) >= bestScore;
+    };
+}

package/dist/types/current/streaming/util/segment.d.ts

@@ -0,0 +1,28 @@
+import type { MediaSegmentMetadata } from '../../streaming/SegmentReference';
+/**
+ * Returns the segment whose range covers `time` (`startTime <= time < endTime`), or
+ * — when `affordance > 0` — the next segment if `time` falls within `affordance`
+ * seconds before its `startTime`. Returns `null` if neither applies.
+ *
+ * Note: with `affordance > 0`, when `time` lies in the last `affordance` seconds of a
+ * segment that does cover it, the *next* segment is returned instead. This is
+ * deliberate — callers use `affordance` to absorb sub-second boundary differences
+ * across qualities — but it means the result is not strictly the segment containing
+ * `time`. Callers needing exact containment should pass `affordance = 0`.
+ *
+ * @param time Lookup time, in seconds.
+ * @param segments Segments sorted by `startTime` ascending.
+ * @param affordance Forward-snap tolerance in seconds: if `time` falls just before a
+ * segment's `startTime` (within `affordance`), that segment is returned. The original
+ * `time` is still compared against `endTime`, so coverage never extends past it.
+ */
+export declare function getSegmentAtTime<T extends MediaSegmentMetadata>(time: number, segments: readonly T[], affordance?: number): T | null;
+/**
+ * Returns the count of segments whose `startTime <= time` — i.e. the index at which a
+ * segment with that `startTime` would be inserted to keep the array sorted ascending.
+ *
+ * @param time Lookup time, in seconds.
+ * @param segments Segments sorted by `startTime` ascending.
+ */
+export declare function getSegmentInsertionIndexAtTime(time: number, segments: readonly MediaSegmentMetadata[]): number;
+//# sourceMappingURL=segment.d.ts.map

package/dist/types/current/streaming/util/segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segment.d.ts","sourceRoot":"","sources":["../../../../../src/streaming/util/segment.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAA;AAExE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,oBAAoB,EAC3D,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,SAAS,CAAC,EAAE,EACtB,UAAU,SAAI,GACf,CAAC,GAAG,IAAI,CAMV;AAED;;;;;;GAMG;AACH,wBAAgB,8BAA8B,CAC1C,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,SAAS,oBAAoB,EAAE,GAC1C,MAAM,CAMR"}

package/dist/types/current/streaming/util/segment.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { sortedInsertionIndex } from '@amazon/vinyl-util';
+/**
+ * Returns the segment whose range covers `time` (`startTime <= time < endTime`), or
+ * — when `affordance > 0` — the next segment if `time` falls within `affordance`
+ * seconds before its `startTime`. Returns `null` if neither applies.
+ *
+ * Note: with `affordance > 0`, when `time` lies in the last `affordance` seconds of a
+ * segment that does cover it, the *next* segment is returned instead. This is
+ * deliberate — callers use `affordance` to absorb sub-second boundary differences
+ * across qualities — but it means the result is not strictly the segment containing
+ * `time`. Callers needing exact containment should pass `affordance = 0`.
+ *
+ * @param time Lookup time, in seconds.
+ * @param segments Segments sorted by `startTime` ascending.
+ * @param affordance Forward-snap tolerance in seconds: if `time` falls just before a
+ * segment's `startTime` (within `affordance`), that segment is returned. The original
+ * `time` is still compared against `endTime`, so coverage never extends past it.
+ */
+export function getSegmentAtTime(time, segments, affordance = 0) {
+    const index = getSegmentInsertionIndexAtTime(time + affordance, segments) - 1;
+    if (index < 0)
+        return null;
+    const segment = segments[index];
+    return time >= segment.endTime ? null : segment;
+}
+/**
+ * Returns the count of segments whose `startTime <= time` — i.e. the index at which a
+ * segment with that `startTime` would be inserted to keep the array sorted ascending.
+ *
+ * @param time Lookup time, in seconds.
+ * @param segments Segments sorted by `startTime` ascending.
+ */
+export function getSegmentInsertionIndexAtTime(time, segments) {
+    return sortedInsertionIndex(segments, time, (time, element) => time - element.startTime);
+}