@amazon/vinyl 1.2.0 → 1.2.2

package/dist/types/current/playback/createStallMonitor.d.ts

@@ -0,0 +1,45 @@
+import { type Timestamp } from '@amazon/vinyl-util';
+import type { ReadonlyPlaybackController } from './ReadonlyPlaybackController';
+import { StallEndedReason } from './ReadonlyPlaybackController';
+export interface StallMonitorOptions {
+    /**
+     * Seconds the play head must be frozen (no `timeUpdate`) while playing before a stall is
+     * reported. Default: 1
+     */
+    readonly stallThreshold?: number;
+    /**
+     * How often (seconds) the play head freeze is checked. Default: 0.25
+     */
+    readonly pollInterval?: number;
+}
+export interface StallEndedInfo {
+    /** Time of the last `timeUpdate` observed before the play head froze. */
+    readonly started: Timestamp;
+    /** Time the stall ended. */
+    readonly ended: Timestamp;
+    /** Total seconds the play head was frozen. */
+    readonly duration: number;
+    /** Why the stall ended. */
+    readonly reason: StallEndedReason;
+}
+export interface StallMonitorCallbacks {
+    /** Called when a stall is first detected. */
+    readonly onStallEntered: () => void;
+    /** Called when a detected stall ends. */
+    readonly onStallEnded: (info: StallEndedInfo) => void;
+}
+/**
+ * Watches a {@link ReadonlyPlaybackController} for stalls while playing: the play head freezing
+ * (no `timeUpdate`) for longer than {@link StallMonitorOptions.stallThreshold} seconds.
+ *
+ * Detection only runs once playback has actually been observed (a `playing` event) and is
+ * suspended on `pause`/`seeking`/`emptied` until playback is observed again — so a stall is never
+ * reported during initial loading or while awaiting a seek. A detected stall ends when the play
+ * head advances again (`playing`) or playback stops for another reason (`pause`/`seeking`/
+ * `emptied`); {@link StallEndedInfo.duration} is measured from the last `timeUpdate` before the
+ * freeze, so it reflects the full frozen time rather than only the time past the threshold.
+ *
+ * Returns a function that stops the monitor.
+ */
+export declare function createStallMonitor(controller: ReadonlyPlaybackController, callbacks: StallMonitorCallbacks, options?: StallMonitorOptions): () => void;
+//# sourceMappingURL=createStallMonitor.d.ts.map

package/dist/types/current/playback/createStallMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createStallMonitor.d.ts","sourceRoot":"","sources":["../../../../src/playback/createStallMonitor.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkB,KAAK,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACnE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAA;AAC9E,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AAE/D,MAAM,WAAW,mBAAmB;IAChC;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;IAEhC;;OAEG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CACjC;AAED,MAAM,WAAW,cAAc;IAC3B,yEAAyE;IACzE,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAA;IAC3B,4BAA4B;IAC5B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;IACzB,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,2BAA2B;IAC3B,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAA;CACpC;AAED,MAAM,WAAW,qBAAqB;IAClC,6CAA6C;IAC7C,QAAQ,CAAC,cAAc,EAAE,MAAM,IAAI,CAAA;IACnC,yCAAyC;IACzC,QAAQ,CAAC,YAAY,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,CAAA;CACxD;AASD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAC9B,UAAU,EAAE,0BAA0B,EACtC,SAAS,EAAE,qBAAqB,EAChC,OAAO,GAAE,mBAAwB,GAClC,MAAM,IAAI,CA+EZ"}

package/dist/types/current/playback/createStallMonitor.js

@@ -0,0 +1,99 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createDisposer } from '@amazon/vinyl-util';
+import { StallEndedReason } from './ReadonlyPlaybackController';
+/**
+ * Minimum forward `currentTime` change (seconds) that counts as real progress. Guards the
+ * progress check against floating-point jitter so a negligible advance isn't mistaken for the
+ * play head moving.
+ */
+const PROGRESS_EPSILON = 1e-6;
+/**
+ * Watches a {@link ReadonlyPlaybackController} for stalls while playing: the play head freezing
+ * (no `timeUpdate`) for longer than {@link StallMonitorOptions.stallThreshold} seconds.
+ *
+ * Detection only runs once playback has actually been observed (a `playing` event) and is
+ * suspended on `pause`/`seeking`/`emptied` until playback is observed again — so a stall is never
+ * reported during initial loading or while awaiting a seek. A detected stall ends when the play
+ * head advances again (`playing`) or playback stops for another reason (`pause`/`seeking`/
+ * `emptied`); {@link StallEndedInfo.duration} is measured from the last `timeUpdate` before the
+ * freeze, so it reflects the full frozen time rather than only the time past the threshold.
+ *
+ * Returns a function that stops the monitor.
+ */
+export function createStallMonitor(controller, callbacks, options = {}) {
+    const stallThresholdMs = (options.stallThreshold ?? 1) * 1000;
+    const pollIntervalMs = (options.pollInterval ?? 0.25) * 1000;
+    // Only detect once playback has been observed; gates out initial load and post-seek buffering.
+    let observedPlaying = false;
+    // Wall-clock time of the last `timeUpdate` — the reference start of any freeze.
+    let lastProgressAt = Date.now();
+    let inStall = false;
+    let pollId = null;
+    const { add, dispose } = createDisposer();
+    const endStall = (reason) => {
+        if (!inStall)
+            return;
+        inStall = false;
+        const ended = Date.now();
+        callbacks.onStallEnded({
+            started: lastProgressAt,
+            ended,
+            duration: (ended - lastProgressAt) / 1000,
+            reason,
+        });
+    };
+    const stopPoll = () => {
+        if (pollId == null)
+            return;
+        clearInterval(pollId);
+        pollId = null;
+    };
+    add(stopPoll);
+    const startPoll = () => {
+        if (pollId != null)
+            return;
+        pollId = setInterval(() => {
+            if (inStall || !observedPlaying)
+                return;
+            if (Date.now() - lastProgressAt >= stallThresholdMs) {
+                inStall = true;
+                callbacks.onStallEntered();
+            }
+        }, pollIntervalMs);
+    };
+    // Playback stopped for a non-resume reason: close any open stall and suspend detection until
+    // playback is observed again.
+    const suspend = (reason) => {
+        endStall(reason);
+        observedPlaying = false;
+        stopPoll();
+    };
+    add(controller.on('playing', () => {
+        // Resuming from a stall closes it (using the pre-resume freeze start for its duration).
+        if (inStall)
+            endStall(StallEndedReason.PLAYING);
+        // Whether resuming or freshly starting, the play head is advancing again, so restart the
+        // freeze clock. Without this the poll could immediately re-detect a stall from the stale
+        // pre-freeze timestamp before the first post-resume `timeUpdate` resets it.
+        lastProgressAt = Date.now();
+        observedPlaying = true;
+        startPoll();
+    }));
+    add(controller.on('timeUpdate', ({ previous, current }) => {
+        // Browsers emit `timeUpdate` while frozen (unchanged/backward `currentTime`); only a
+        // forward advance is progress, else a stall is ended and re-detected, doubling events.
+        if (previous != null && current - previous <= PROGRESS_EPSILON)
+            return;
+        // The play head advanced: close any open stall, then reset the freeze clock.
+        if (inStall)
+            endStall(StallEndedReason.PLAYING);
+        lastProgressAt = Date.now();
+    }));
+    add(controller.on('pause', () => suspend(StallEndedReason.PAUSE)));
+    add(controller.on('seeking', () => suspend(StallEndedReason.SEEKING)));
+    add(controller.on('emptied', () => suspend(StallEndedReason.EMPTIED)));
+    return dispose;
+}

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

@@ -0,0 +1,66 @@
+import type { ObjectSchema } from '@amazon/vinyl-validation';
+import type { Maybe } from '@amazon/vinyl-util';
+/**
+ * Criteria used to pick which audio rendition to play.
+ */
+export interface AudioSelection {
+    /**
+     * Preferred language(s) for audio content, as RFC 5646 codes (e.g. `'en'`,
+     * `'ja'`, `'fr-CA'`). May be a single tag or an ordered list of tags —
+     * earlier entries are preferred, with the best relatedness match kept for
+     * each period (audio without a language tag is always kept). `null` (the
+     * default) is NOT "no preference": it orders by the platform's
+     * `navigator.languages`. To keep every language, this option is not the
+     * mechanism — omit language content or pass a tag matching all.
+     */
+    readonly language?: string | readonly string[] | null;
+    /**
+     * Opt in to audio-description (a.k.a. described-video / DVS) audio: audio
+     * renditions carrying an accessibility "describes video" characteristic that
+     * narrate on-screen action. `false` (the default) keeps them out of the
+     * automatic default-audio selection — they are chosen only when this is set.
+     * When `true`, a description rendition is preferred where one exists for the
+     * selected language. Changing this reselects audio immediately.
+     */
+    readonly descriptive?: boolean;
+}
+/**
+ * Declarative audio configuration. Mirrors `VinylOptions.text`: the audio
+ * rendition is chosen from {@link selection}; changing it reselects audio
+ * immediately.
+ */
+export interface AudioOptions {
+    /**
+     * The audio selection criteria (language / descriptive).
+     */
+    readonly selection?: AudioSelection;
+    /**
+     * When `true`, disables the audio sampling-rate support filter, so audio
+     * renditions whose sampling rate exceeds what the platform reports (via the
+     * `AudioContext` output rate) are kept and offered to playback anyway.
+     * `false` (the default) applies the filter. Changing this re-filters the
+     * timeline immediately.
+     */
+    readonly disableSampleRateFilter?: boolean;
+    /**
+     * The maximum audio sampling rate (Hz) the sampling-rate filter treats as
+     * supported. When set, it takes precedence over the platform's
+     * `AudioContext`-reported output rate. Ignored when
+     * {@link disableSampleRateFilter} is `true`. Changing this re-filters the
+     * timeline immediately. `null`/`undefined` falls back to the reported rate.
+     */
+    readonly maxSampleRate?: Maybe<number>;
+    /**
+     * The minimum audio sampling rate (Hz) the sampling-rate filter treats as
+     * supported. When set, renditions below it are filtered out as a soft floor
+     * (if every audio rendition is below it, the highest is kept so playback is
+     * never stranded). Applied alongside the max cap whenever the filter runs,
+     * regardless of how the max was determined; ignored when
+     * {@link disableSampleRateFilter} is `true`. Changing this re-filters the
+     * timeline immediately.
+     */
+    readonly minSampleRate?: Maybe<number>;
+}
+export declare const defaultAudioOptions: AudioOptions;
+export declare const audioOptionsValidator: ObjectSchema<AudioOptions>;
+//# sourceMappingURL=AudioOptions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AudioOptions.d.ts","sourceRoot":"","sources":["../../../../src/streaming/AudioOptions.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAQ5D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAE/C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC3B;;;;;;;;OAQG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,IAAI,CAAA;IAErD;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CACjC;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IACzB;;OAEG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,cAAc,CAAA;IAEnC;;;;;;OAMG;IACH,QAAQ,CAAC,uBAAuB,CAAC,EAAE,OAAO,CAAA;IAE1C;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAEtC;;;;;;;;OAQG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;CACzC;AAED,eAAO,MAAM,mBAAmB,EAAE,YAGjC,CAAA;AAOD,eAAO,MAAM,qBAAqB,EAAE,YAAY,CAAC,YAAY,CAK3D,CAAA"}

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

@@ -0,0 +1,19 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { array, boolean, number, object, string, } from '@amazon/vinyl-validation';
+export const defaultAudioOptions = {
+    selection: { language: null, descriptive: false },
+    disableSampleRateFilter: false,
+};
+const audioSelectionValidator = object({
+    language: string().or(array(string()).readonly()).orNull().optional(),
+    descriptive: boolean().optional(),
+});
+export const audioOptionsValidator = object({
+    selection: audioSelectionValidator.optional(),
+    disableSampleRateFilter: boolean().optional(),
+    maxSampleRate: number().maybe().optional(),
+    minSampleRate: number().maybe().optional(),
+});

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

@@ -0,0 +1,72 @@
+import type { Timestamp } from '@amazon/vinyl-util';
+import type { TrackUri } from '../track/Track';
+import type { ContentType } from './MediaQualityMetadata';
+/**
+ * The stage of the track-load journey a {@link LoadSpanMeasurement} describes.
+ *
+ * - `manifest`: fetching and parsing the DASH/HLS manifest.
+ * - `keySetup`: the EME/CDM setup, from session creation to the CDM's first
+ *   license message. Precedes and is contiguous with `license`.
+ * - `license`: the DRM license request/response exchange.
+ * - `initSegment`: fetching the initialization segment.
+ * - `firstSegment`: fetching the first media segment.
+ */
+export type LoadSpanKind = 'manifest' | 'keySetup' | 'license' | 'initSegment' | 'firstSegment';
+/**
+ * A timed span for one stage of a track load.
+ *
+ * Dispatched by the controller that owns the stage. Emitters attribute the span
+ * to the track it was measured for at the source (see {@link trackUri}); the
+ * player republishes it as a {@link LoadSpanEvent}. When the emitter cannot know
+ * the owning track, `trackUri` is omitted and the span is dropped rather than
+ * misattributed.
+ */
+export interface LoadSpanMeasurement {
+    readonly kind: LoadSpanKind;
+    /**
+     * When the stage began, as a unix millisecond timestamp.
+     */
+    readonly startTime: Timestamp;
+    /**
+     * When the stage completed, as a unix millisecond timestamp.
+     */
+    readonly endTime: Timestamp;
+    /**
+     * The track this span was measured for, stamped at the source by the
+     * emitter that knows which track initiated the load. Omitted only when the
+     * initiating track is not yet known (e.g. an encrypted event handled before
+     * buffering DRM info is set).
+     */
+    readonly trackUri?: TrackUri;
+    /**
+     * The MIME type of the content this span was measured for, when known. Set
+     * for DRM `license` spans so a certificate exchange and the per-content-type
+     * license exchanges are distinguishable.
+     */
+    readonly mimeType?: string;
+    /**
+     * The content type this span was measured for, when known. Set alongside
+     * {@link mimeType} for DRM `license` spans.
+     */
+    readonly contentType?: ContentType;
+}
+/**
+ * A {@link LoadSpanMeasurement} attributed to the track it was measured for.
+ *
+ * Emitted on the player as the `loadSpan` event.
+ */
+export interface LoadSpanEvent extends LoadSpanMeasurement {
+    readonly trackUri: TrackUri;
+}
+/**
+ * Player-level load metric events.
+ */
+export interface LoadMetricEventMap {
+    /**
+     * A stage of a track load completed. Reports the time span of the stage
+     * together with the track it belongs to. Consumers measuring end-to-end
+     * load latency key on the first event per `kind` and `trackUri`.
+     */
+    readonly loadSpan: LoadSpanEvent;
+}
+//# sourceMappingURL=LoadMetric.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LoadMetric.d.ts","sourceRoot":"","sources":["../../../../src/streaming/LoadMetric.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAC9C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAEzD;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GACpB,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,aAAa,GAAG,cAAc,CAAA;AAExE;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAChC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAE3B;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;IAE7B;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAA;IAE3B;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAA;IAE5B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAE1B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,WAAW,CAAA;CACrC;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAc,SAAQ,mBAAmB;IACtD,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAA;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAA;CACnC"}

package/dist/types/current/streaming/LoadMetric.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/streaming/ManifestControllerImpl.d.ts

@@ -0,0 +1,43 @@
+import { type MutableValue } from '@amazon/vinyl-observable';
+import { type EventHandler, type SignalOptions, type Unsubscribe } from '@amazon/vinyl-util';
+import type { ManifestController, ManifestControllerEventMap, ManifestProvider } from './ManifestController';
+export interface ManifestControllerImplDeps<T> {
+    readonly manifestProvider: ManifestProvider<T>;
+}
+export declare class ManifestControllerImpl<T> implements ManifestController<Promise<T>> {
+    private readonly deps;
+    get [Symbol.toStringTag](): string;
+    get logPrefix(): string;
+    private readonly _data;
+    private _error;
+    private readonly abortSlot;
+    private readonly disposer;
+    private readonly events;
+    private manifestSpanArmed;
+    constructor(deps: ManifestControllerImplDeps<T>);
+    on<K extends keyof ManifestControllerEventMap>(type: K, handler: EventHandler<ManifestControllerEventMap[K]>, options?: SignalOptions): Unsubscribe;
+    hasAnyListeners(): boolean;
+    hasListeners(type: keyof ManifestControllerEventMap): boolean;
+    readonly __eventMapType: import("@amazon/vinyl-util").Covariant<ManifestControllerEventMap>;
+    /**
+     * The most recent error from the manifest provider, or null.
+     */
+    get error(): Error | null;
+    refresh(): void;
+    private requestManifest;
+    /**
+     * Measures the initial manifest fetch as a load span, re-arming on failure
+     * so a recovered load is still measured.
+     */
+    private measureLoadSpan;
+    reset(): void;
+    get value(): Promise<T>;
+    get changeId(): number;
+    getValue(): Promise<T>;
+    onData(callback: (value: Promise<T>, previous?: Promise<T>) => void): () => void;
+    map<U>(fn: (value: Promise<T>) => U): import("@amazon/vinyl-observable").ObservableValue<U>;
+    pick<K extends keyof NonNullable<Promise<T>>>(key: K): MutableValue<Promise<T>[K]>;
+    get disposed(): boolean;
+    dispose(): void;
+}
+//# sourceMappingURL=ManifestControllerImpl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ManifestControllerImpl.d.ts","sourceRoot":"","sources":["../../../../src/streaming/ManifestControllerImpl.ts"],"names":[],"mappings":"AAKA,OAAO,EAAQ,KAAK,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAClE,OAAO,EAGH,KAAK,YAAY,EAGjB,KAAK,aAAa,EAClB,KAAK,WAAW,EACnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,EACR,kBAAkB,EAClB,0BAA0B,EAC1B,gBAAgB,EACnB,MAAM,sBAAsB,CAAA;AAE7B,MAAM,WAAW,0BAA0B,CAAC,CAAC;IACzC,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAA;CACjD;AAED,qBAAa,sBAAsB,CAAC,CAAC,CAAE,YAAW,kBAAkB,CAChE,OAAO,CAAC,CAAC,CAAC,CACb;IAgBe,OAAO,CAAC,QAAQ,CAAC,IAAI;IAfjC,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;IAED,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA0B;IAChD,OAAO,CAAC,MAAM,CAAqB;IACnC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;IAC9C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAmB;IAC5C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAkD;IACzE,OAAO,CAAC,iBAAiB,CAAO;gBAEH,IAAI,EAAE,0BAA0B,CAAC,CAAC,CAAC;IAMhE,EAAE,CAAC,CAAC,SAAS,MAAM,0BAA0B,EACzC,IAAI,EAAE,CAAC,EACP,OAAO,EAAE,YAAY,CAAC,0BAA0B,CAAC,CAAC,CAAC,CAAC,EACpD,OAAO,CAAC,EAAE,aAAa,GACxB,WAAW;IAId,eAAe,IAAI,OAAO;IAI1B,YAAY,CAAC,IAAI,EAAE,MAAM,0BAA0B,GAAG,OAAO;IAI7D,QAAQ,CAAC,cAAc,qEAA6B;IAEpD;;OAEG;IACH,IAAI,KAAK,IAAI,KAAK,GAAG,IAAI,CAExB;IAED,OAAO,IAAI,IAAI;IAKf,OAAO,CAAC,eAAe;IAWvB;;;OAGG;IACH,OAAO,CAAC,eAAe;IAevB,KAAK,IAAI,IAAI;IAOb,IAAI,KAAK,IAAI,OAAO,CAAC,CAAC,CAAC,CAEtB;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,QAAQ,IAAI,OAAO,CAAC,CAAC,CAAC;IAItB,MAAM,CACF,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,GAC7D,MAAM,IAAI;IAIb,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC;IAInC,IAAI,CAAC,CAAC,SAAS,MAAM,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC;IAIpD,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,OAAO,IAAI,IAAI;CAKlB"}

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

@@ -0,0 +1,104 @@
+/*
+ * 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, EventHostImpl, logDebug, } from '@amazon/vinyl-util';
+export class ManifestControllerImpl {
+    deps;
+    get [Symbol.toStringTag]() {
+        return 'ManifestControllerImpl';
+    }
+    get logPrefix() {
+        return 'ManifestControllerImpl';
+    }
+    _data;
+    _error = null;
+    abortSlot = createAbortSlot();
+    disposer = createDisposer();
+    events = new EventHostImpl();
+    manifestSpanArmed = true;
+    constructor(deps) {
+        this.deps = deps;
+        // Kick off the initial manifest request. requestManifest() attaches its
+        // own rejection handler, so the stored promise never rejects unhandled.
+        this._data = data(this.requestManifest());
+    }
+    on(type, handler, options) {
+        return this.events.on(type, handler, options);
+    }
+    hasAnyListeners() {
+        return this.events.hasAnyListeners();
+    }
+    hasListeners(type) {
+        return this.events.hasListeners(type);
+    }
+    __eventMapType = this.events.__eventMapType;
+    /**
+     * The most recent error from the manifest provider, or null.
+     */
+    get error() {
+        return this._error;
+    }
+    refresh() {
+        logDebug(this, 'refresh');
+        this._data.value = this.requestManifest();
+    }
+    requestManifest() {
+        this.abortSlot.abort();
+        this._error = null;
+        const promise = this.deps.manifestProvider(this.abortSlot.value);
+        this.measureLoadSpan(promise);
+        promise.catch((error) => {
+            this._error = error;
+        });
+        return promise;
+    }
+    /**
+     * Measures the initial manifest fetch as a load span, re-arming on failure
+     * so a recovered load is still measured.
+     */
+    measureLoadSpan(promise) {
+        if (!this.manifestSpanArmed)
+            return;
+        this.manifestSpanArmed = false;
+        const startTime = Date.now();
+        promise.then(() => this.events.dispatch('loadSpanMeasured', {
+            kind: 'manifest',
+            startTime,
+            endTime: Date.now(),
+        }), () => (this.manifestSpanArmed = true));
+    }
+    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();
+        this.events.dispose();
+    }
+}

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

@@ -0,0 +1,23 @@
+/**
+ * Records every codec in the given mimeType as denylisted. Returns true if any
+ * codec was newly added (i.e. was not already denylisted), false if all codecs
+ * were already present. The return value lets callers bound retry loops: a
+ * repeat failure for an already-denylisted codec should not trigger another
+ * fallback attempt.
+ */
+export declare function denylistCodecsFromMimeType(mimeType: string): boolean;
+/**
+ * Returns true when any codec in the given mimeType has been denylisted.
+ */
+export declare function isMimeTypeDenylisted(mimeType: string): boolean;
+/**
+ * Returns the currently denylisted codec strings (lowercased). Primarily for
+ * diagnostics and testing.
+ */
+export declare function getDenylistedCodecs(): readonly string[];
+/**
+ * Clears the runtime codec denylist. Intended for tests and for re-detecting
+ * support (e.g. after an environment change).
+ */
+export declare function clearCodecDenylist(): void;
+//# sourceMappingURL=codecDenylist.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"codecDenylist.d.ts","sourceRoot":"","sources":["../../../../../src/streaming/buffering/codecDenylist.ts"],"names":[],"mappings":"AAyBA;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAWpE;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAG9D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,IAAI,SAAS,MAAM,EAAE,CAEvD;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CAEzC"}

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

@@ -0,0 +1,62 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { extractCodecs } from '../../util/media/codecSupport';
+/**
+ * A runtime denylist of media codecs that failed to decode after a SourceBuffer
+ * append, despite the browser reporting them as supported.
+ *
+ * Some browsers report a codec as supported via `MediaSource.isTypeSupported`
+ * yet fail to decode it (e.g. HEVC on Chromium without a platform decoder),
+ * surfacing as an append/decode error only once media is fed to the
+ * SourceBuffer. When that happens, the failing codec is recorded here so that
+ * quality selection avoids it and playback can fall back to a codec that does
+ * decode.
+ *
+ * This mirrors the runtime {@link getSourceBufferQuota} learning: it is a
+ * process-wide singleton learned from real append failures, with a reset hook
+ * for tests and re-detection. Entries are the individual RFC 6381 codec
+ * strings (e.g. `hvc1.2.20000000.L123.B0`), stored lowercased.
+ */
+const denylistedCodecs = new Set();
+/**
+ * Records every codec in the given mimeType as denylisted. Returns true if any
+ * codec was newly added (i.e. was not already denylisted), false if all codecs
+ * were already present. The return value lets callers bound retry loops: a
+ * repeat failure for an already-denylisted codec should not trigger another
+ * fallback attempt.
+ */
+export function denylistCodecsFromMimeType(mimeType) {
+    const codecs = extractCodecs(mimeType);
+    let added = false;
+    for (const codec of codecs) {
+        const lower = codec.toLowerCase();
+        if (!denylistedCodecs.has(lower)) {
+            denylistedCodecs.add(lower);
+            added = true;
+        }
+    }
+    return added;
+}
+/**
+ * Returns true when any codec in the given mimeType has been denylisted.
+ */
+export function isMimeTypeDenylisted(mimeType) {
+    const codecs = extractCodecs(mimeType);
+    return codecs.some((c) => denylistedCodecs.has(c.toLowerCase()));
+}
+/**
+ * Returns the currently denylisted codec strings (lowercased). Primarily for
+ * diagnostics and testing.
+ */
+export function getDenylistedCodecs() {
+    return [...denylistedCodecs];
+}
+/**
+ * Clears the runtime codec denylist. Intended for tests and for re-detecting
+ * support (e.g. after an environment change).
+ */
+export function clearCodecDenylist() {
+    denylistedCodecs.clear();
+}

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

@@ -0,0 +1,30 @@
+import type { RestrictableContentType } from './MediaQualityMetadata';
+import type { ContentTypesValue } from './ContentTypesValue';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+export interface AllowedContentTypesValueDeps {
+    /**
+     * The unfiltered content types present in the manifest.
+     */
+    readonly baseContentTypesValue: ContentTypesValue;
+    /**
+     * The player options. The `allowedContentTypes` allow list restricts which
+     * media content types are streamed; `null` means no restriction.
+     */
+    readonly options: ObservableValue<{
+        readonly allowedContentTypes: readonly RestrictableContentType[] | null;
+    }>;
+}
+/**
+ * Wraps a {@link ContentTypesValue} with the `allowedContentTypes` allow list
+ * from the player options. When the allow list is set, only media content
+ * types (`'audio'`, `'video'`) in the list are emitted; other media streams
+ * are ignored. When it is `null`, the underlying content types pass through
+ * unchanged. Text is never restricted by the allow list and always passes
+ * through (captions are governed by caption selection).
+ *
+ * Because the result is derived from the `allowedContentTypes` option via
+ * {@link combineData}, changing the option re-emits a newly filtered set, which
+ * reloads the track using only the allowed content types.
+ */
+export declare function createAllowedContentTypesValue(deps: AllowedContentTypesValueDeps): ContentTypesValue;
+//# sourceMappingURL=createAllowedContentTypesValue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createAllowedContentTypesValue.d.ts","sourceRoot":"","sources":["../../../../src/streaming/createAllowedContentTypesValue.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAER,uBAAuB,EAC1B,MAAM,wBAAwB,CAAA;AAC/B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAI/D,MAAM,WAAW,4BAA4B;IACzC;;OAEG;IACH,QAAQ,CAAC,qBAAqB,EAAE,iBAAiB,CAAA;IAEjD;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,eAAe,CAAC;QAC9B,QAAQ,CAAC,mBAAmB,EAAE,SAAS,uBAAuB,EAAE,GAAG,IAAI,CAAA;KAC1E,CAAC,CAAA;CACL;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,8BAA8B,CAC1C,IAAI,EAAE,4BAA4B,GACnC,iBAAiB,CAOnB"}

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

@@ -0,0 +1,43 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { combineData } from '@amazon/vinyl-observable';
+/**
+ * Wraps a {@link ContentTypesValue} with the `allowedContentTypes` allow list
+ * from the player options. When the allow list is set, only media content
+ * types (`'audio'`, `'video'`) in the list are emitted; other media streams
+ * are ignored. When it is `null`, the underlying content types pass through
+ * unchanged. Text is never restricted by the allow list and always passes
+ * through (captions are governed by caption selection).
+ *
+ * Because the result is derived from the `allowedContentTypes` option via
+ * {@link combineData}, changing the option re-emits a newly filtered set, which
+ * reloads the track using only the allowed content types.
+ */
+export function createAllowedContentTypesValue(deps) {
+    return combineData({
+        contentTypes: deps.baseContentTypesValue,
+        allowedContentTypes: deps.options.pick('allowedContentTypes'),
+    }).map(async ({ contentTypes, allowedContentTypes }) => {
+        return filterContentTypes(await contentTypes, allowedContentTypes);
+    });
+}
+/**
+ * Returns the subset of `contentTypes` permitted by the `allowedContentTypes`
+ * allow list. A `null` allow list permits everything. Text always passes
+ * through regardless of the allow list.
+ */
+function filterContentTypes(contentTypes, allowedContentTypes) {
+    if (allowedContentTypes == null)
+        return contentTypes;
+    const allowed = new Set(allowedContentTypes);
+    const filtered = new Set();
+    for (const contentType of contentTypes) {
+        // Text is not subject to the allow list; keep it regardless.
+        if (contentType === 'text' || allowed.has(contentType)) {
+            filtered.add(contentType);
+        }
+    }
+    return filtered;
+}