@amazon/vinyl 1.1.1 → 1.2.0

package/dist/types/ts4.7/track/dash/createDashFactories.d.ts

@@ -1,11 +1,11 @@
-import type { DashTrackLoadOptions } from '../../track/dash/DashTrack';
+import type { DashTrackLoadOptions } from './DashTrack';
 import { type Maybe, type RequestInterceptor } from '@amazon/vinyl-util';
-import { createDefaultDashManifestTransformer } from '../../track/dash/createDefaultDashManifestTransformer';
+import { createDefaultDashManifestTransformer } from './createDefaultDashManifestTransformer';
 import { createMediaSource } from '../../util/media/mediaSource';
-import { type DashMediaQualityMetadataResolverDeps } from '../../track/dash/DashMediaQualityMetadataResolver';
+import { type DashMediaQualityMetadataResolverDeps } from './DashMediaQualityMetadataResolver';
 import { MediaSourceControllerImpl, type MediaSourceControllerImplDeps } from '../../streaming/buffering/MediaSourceController';
 import type { PlaybackController } from '../../playback/PlaybackController';
-import { type DashManifestController, type DashManifestControllerImplDeps } from '../../track/dash/DashManifestController';
+import { type DashManifestController, type DashManifestControllerImplDeps } from './DashManifestController';
 import type { DrmKeySystemResolver } from '../../drm/DrmKeySystemResolver';
 import type { DrmController } from '../../drm/DrmController';
 import type { Capabilities } from '../../client/Capabilities';
@@ -13,12 +13,12 @@ import { QualitySelectorImpl, type QualitySelectorImplOptions } from '../../stre
 import type { PlaybackSource } from '../../playback/PlaybackSource';
 import { createContentStreamFactory } from '../../streaming/ContentStream';
 import type { ContentStreamingOptions } from '../../streaming/ContentStreamingOptions';
-import { createDashContentTypesValue } from '../../track/dash/createDashContentTypesValue';
+import { createDashContentTypesValue } from './createDashContentTypesValue';
 import type { ObservableValue } from '@amazon/vinyl-observable';
 import type { VinylOptions } from '../../vinyl/VinylOptions';
-import { type BuildDashMediaTimelineDeps } from '../../track/dash/buildDashMediaTimeline';
+import { type BuildDashMediaTimelineDeps } from './buildDashMediaTimeline';
 import { createDefaultMediaTimelineTransformer } from '../../streaming/createDefaultMediaTimelineTransformer';
-import type { DashManifestData } from '../../track/dash/DashManifestProvider';
+import type { DashManifestData } from './DashManifestProvider';
 /**
  * Player-level dependencies needed for the Dash-specific factories.
  */
@@ -43,20 +43,20 @@ export type DashInitOptions = {
  */
 export declare function createDashFactories(options: Maybe<DashInitOptions>): (deps: DashFactoryDeps) => (loadOptions: DashTrackLoadOptions) => {
     contentTypesValue: typeof createDashContentTypesValue;
-    baseUrlSelector: () => import("../../track/dash/util/uriResolution").BaseUrlSelector;
+    baseUrlSelector: () => import("./util/uriResolution").BaseUrlSelector;
     segmentRequestInit: () => Maybe<Readonly<Omit<RequestInit, "signal">>>;
     manifestProvider: (deps: {
         readonly requestInterceptor: RequestInterceptor;
-    }) => import("../../track/dash/DashManifestProvider").DashManifestProvider;
+    }) => import("./DashManifestProvider").DashManifestProvider;
     manifestController: (deps: DashManifestControllerImplDeps) => DashManifestController;
     mediaSourceFactory: () => typeof createMediaSource;
-    mediaQualityMetadataResolver: (deps: DashMediaQualityMetadataResolverDeps) => import("../../track/dash/DashMediaQualityMetadataResolver").DashMediaQualityMetadataResolver;
+    mediaQualityMetadataResolver: (deps: DashMediaQualityMetadataResolverDeps) => import("./DashMediaQualityMetadataResolver").DashMediaQualityMetadataResolver;
     mediaSourceController: (deps: MediaSourceControllerImplDeps) => MediaSourceControllerImpl;
-    createContentStreamFactories: (deps: import("../../track/dash/createDashContentStreamFactories").DashContentStreamTrackDeps) => import("@amazon/vinyl-util").MemoizedFunction & ((contentType: import("../..").ContentType) => {
+    createContentStreamFactories: (deps: import("./createDashContentStreamFactories").DashContentStreamTrackDeps) => import("@amazon/vinyl-util").MemoizedFunction & ((contentType: import("../..").ContentType) => {
         sourceBufferControllerFactory: (deps: import("../..").SourceBufferControllerImplDeps) => () => import("../..").SourceBufferControllerImpl;
         bufferingController: (deps: import("../..").BufferingControllerImplDeps) => import("../..").BufferingControllerImpl;
         segmentController: (deps: import("../..").SegmentControllerImplDeps) => import("../..").SegmentControllerImpl;
-        mediaSourceController: import("@amazon/vinyl-di").Factory<import("../../streaming/buffering/MediaSourceController").MediaSourceController>;
+        mediaSourceController: import("@amazon/vinyl-di").Factory<import("../..").MediaSourceController>;
         playbackController: import("@amazon/vinyl-di").Factory<PlaybackController>;
         mediaTimelineTransformed: import("@amazon/vinyl-di").Factory<ObservableValue<Promise<import("../..").MediaTimeline>>>;
         qualitySelector: import("@amazon/vinyl-di").Factory<import("../..").QualitySelector>;

package/dist/types/ts4.7/track/dash/createDashManifestProvider.d.ts

@@ -1,4 +1,4 @@
-import type { DashTrackLoadOptions } from '../../track/dash/DashTrack';
+import type { DashTrackLoadOptions } from './DashTrack';
 import type { RequestInterceptor } from '@amazon/vinyl-util';
 /**
  * Creates a DashManifestProvider which uses the manifestProvider set on the loadOptions, or a urlDashManifestProvider

package/dist/types/ts4.7/track/dash/createDefaultDashManifestTransformer.d.ts

@@ -1,5 +1,5 @@
 import type { ObservableValue } from '@amazon/vinyl-observable';
-import type { DashManifestData } from '../../track/dash/DashManifestProvider';
+import type { DashManifestData } from './DashManifestProvider';
 import type { AdaptationSetType, RepresentationType } from '@amazon/vinyl-mpd-parser';
 import { type Comparator } from '@amazon/vinyl-util';
 export interface DashManifestTransformerDeps {

package/dist/types/ts4.7/track/dash/manifestTransformUtils.d.ts

@@ -1,5 +1,5 @@
 import type { AdaptationSetType, DashManifest, RepresentationType } from '@amazon/vinyl-mpd-parser';
-import type { DashManifestData } from '../../track/dash/DashManifestProvider';
+import type { DashManifestData } from './DashManifestProvider';
 import type { ObservableValue } from '@amazon/vinyl-observable';
 import { type Comparator, type FilterPredicate, type MaybePromise } from '@amazon/vinyl-util';
 /**

package/dist/types/ts4.7/track/dash/timeline/DashRepresentationSegmentProvider.d.ts

@@ -1,9 +1,9 @@
 import type { RepresentationType } from '@amazon/vinyl-mpd-parser';
-import { type DashUriResolveDeps } from '../../../track/dash/util/uriResolution';
-import { type CreateSegmentDataProviderDeps } from '../../../track/createSegmentDataProvider';
+import { type DashUriResolveDeps } from '../util/uriResolution';
+import { type CreateSegmentDataProviderDeps } from '../../createSegmentDataProvider';
 import type { SegmentReference } from '../../../streaming/SegmentReference';
 import type { SegmentDataProvider } from '../../../streaming/SegmentDataSlot';
-import type { DashMediaQualityMetadataResolver } from '../../../track/dash/DashMediaQualityMetadataResolver';
+import type { DashMediaQualityMetadataResolver } from '../DashMediaQualityMetadataResolver';
 export interface DashSegmentProviderDeps extends DashUriResolveDeps, CreateSegmentDataProviderDeps {
     /**
      * Produces abstract metadata from a dash representation.

package/dist/types/ts4.7/track/dash/urlDashManifestProvider.d.ts

@@ -1,7 +1,7 @@
 import type { Maybe } from '@amazon/vinyl-util';
 import type { RequestInitOptions } from '@amazon/vinyl-util';
 import type { RequestInterceptor } from '@amazon/vinyl-util';
-import type { DashManifestProvider } from '../../track/dash/DashManifestProvider';
+import type { DashManifestProvider } from './DashManifestProvider';
 /**
  * Creates a DashManifestProvider which performs a request to retrieve a dash manifest.
  * Can be a relative path.

package/dist/types/ts4.7/track/dash/util/mpd.d.ts

@@ -74,7 +74,8 @@ export declare function getPeriodAtTime(manifest: DashManifest, time: number): P
 export declare function flattenRepresentations(period: PeriodType): RepresentationType[];
 /**
  * Calculates the manifest duration, either from the mediaPresentationDuration or the last period end time.
- * @param manifest
+ * Returns `Infinity` for live (dynamic) presentations.
+ * Throws if duration cannot be determined.
  */
-export declare function calculateDuration(manifest: DashManifest): number | null;
+export declare function calculateDuration(manifest: DashManifest): number;
 //# sourceMappingURL=mpd.d.ts.map

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

@@ -1,7 +1,7 @@
-import type { HlsManifestData } from '../../track/hls/HlsManifestProvider';
-import type { HlsMediaQualityMetadataResolver } from '../../track/hls/HlsMediaQualityMetadataResolver';
+import type { HlsManifestData } from './HlsManifestProvider';
+import type { HlsMediaQualityMetadataResolver } from './HlsMediaQualityMetadataResolver';
 import type { MediaTimeline } from '../../streaming/MediaTimeline';
-import { type CreateSegmentDataProviderDeps } from '../../track/createSegmentDataProvider';
+import { type CreateSegmentDataProviderDeps } from '../createSegmentDataProvider';
 export interface BuildHlsMediaTimelineDeps extends CreateSegmentDataProviderDeps {
     readonly mediaQualityMetadataResolver: HlsMediaQualityMetadataResolver;
 }

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

@@ -1,5 +1,5 @@
 import type { ObservableValue } from '@amazon/vinyl-observable';
-import type { HlsManifestData } from '../../track/hls/HlsManifestProvider';
+import type { HlsManifestData } from './HlsManifestProvider';
 export interface HlsManifestTransformerDeps {
     readonly manifestController: ObservableValue<Promise<HlsManifestData>>;
 }

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

@@ -1,7 +1,7 @@
 import type { HlsSegment } from '@amazon/vinyl-hls-parser';
 import type { MediaSegmentReference } from '../../../streaming/SegmentReference';
 import type { SegmentDataProvider } from '../../../streaming/SegmentDataSlot';
-import { type CreateSegmentDataProviderDeps } from '../../../track/createSegmentDataProvider';
+import { type CreateSegmentDataProviderDeps } from '../../createSegmentDataProvider';
 /**
  * Builds a timeline of MediaSegmentReferences from an HLS media playlist's
  * segment list. Cumulative durations are used to compute start/end times.

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

@@ -1,6 +1,6 @@
-import { TrackBase, type TrackBaseDeps, type TrackBaseOptions } from '../../track/TrackBase';
+import { TrackBase, type TrackBaseDeps, type TrackBaseOptions } from '../TrackBase';
 import { type ReadonlyRanges, type ReadonlySet } from '@amazon/vinyl-util';
-import type { TrackPreloadOptions, TrackTypeId, TrackUri } from '../../track/Track';
+import type { TrackPreloadOptions, TrackTypeId, TrackUri } from '../Track';
 import type { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
 import { type Factories } from '@amazon/vinyl-di';
 import type { ContentStream } from '../../streaming/ContentStream';

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

@@ -1,4 +1,4 @@
-import type { TrackEventMap } from '../../track/Track';
+import type { TrackEventMap } from '../Track';
 import { EventHostImpl, type ReadonlySet } from '@amazon/vinyl-util';
 import type { PlaybackController } from '../../playback/PlaybackController';
 import type { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';

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

@@ -1,9 +1,9 @@
 import type { PlaybackSource } from '../../playback/PlaybackSource';
-import type { TrackTypeId, TrackUri } from '../../track/Track';
-import { type TrackBaseDeps } from '../../track/TrackBase';
-import { type TrackFactory, type TrackLoadOptions } from '../../track/TrackFactory';
+import type { TrackTypeId, TrackUri } from '../Track';
+import { type TrackBaseDeps } from '../TrackBase';
+import { type TrackFactory, type TrackLoadOptions } from '../TrackFactory';
 import { type Maybe } from '@amazon/vinyl-util';
-import { SourceTrackBase, type SourceTrackBaseOptions } from '../../track/source/SourceTrackBase';
+import { SourceTrackBase, type SourceTrackBaseOptions } from './SourceTrackBase';
 /**
  * Dependencies for a SourceObjectTrack.
  */

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

@@ -1,8 +1,8 @@
-import type { TrackTypeId, TrackUri } from '../../track/Track';
-import { type TrackBaseDeps } from '../../track/TrackBase';
-import { type TrackFactory, type TrackLoadOptions } from '../../track/TrackFactory';
+import type { TrackTypeId, TrackUri } from '../Track';
+import { type TrackBaseDeps } from '../TrackBase';
+import { type TrackFactory, type TrackLoadOptions } from '../TrackFactory';
 import { type Maybe } from '@amazon/vinyl-util';
-import { SourceTrackBase, type SourceTrackBaseOptions } from '../../track/source/SourceTrackBase';
+import { SourceTrackBase, type SourceTrackBaseOptions } from './SourceTrackBase';
 import type { PlaybackSource } from '../../playback/PlaybackSource';
 /**
  * Dependencies for a SourceTrack.

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

@@ -1,5 +1,5 @@
-import { TrackBase, type TrackBaseDeps, type TrackBaseOptions } from '../../track/TrackBase';
-import type { TrackEventMap, TrackPreloadOptions, TrackTypeId, TrackUri } from '../../track/Track';
+import { TrackBase, type TrackBaseDeps, type TrackBaseOptions } from '../TrackBase';
+import type { TrackEventMap, TrackPreloadOptions, TrackTypeId, TrackUri } from '../Track';
 import { type Maybe, type ReadonlySet } from '@amazon/vinyl-util';
 import { type ContentType, type MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
 import type { ObjectSchema } from '@amazon/vinyl-validation';

package/dist/types/ts4.7/vinyl/VinylDeps.d.ts

@@ -7,7 +7,7 @@ import type { TrackLoadOptions } from '../track/TrackFactory';
 import type { DrmController } from '../drm/DrmController';
 import type { AutoResetController } from '../track/AutoResetController';
 import type { MutableValue } from '@amazon/vinyl-observable';
-import type { VinylOptions } from '../vinyl/VinylOptions';
+import type { VinylOptions } from './VinylOptions';
 export interface VinylDeps<TrackLoadOptionsType extends TrackLoadOptions = VinylTrackLoadOptions, OptionsType = VinylOptions> {
     /**
      * A mutable provider for configuration options.

package/dist/types/ts4.7/vinyl/VinylPlayer.d.ts

@@ -11,14 +11,28 @@ import type { DefaultVinylFactories, InferVinylOverrideDependencyType, VinylDepe
 import type { VinylDeps } from './VinylDeps';
 import type { Capabilities } from '../client/Capabilities';
 import { type ContentType, type MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
-import type { ReadonlyPlaybackStreamingState } from '../vinyl/ReadonlyPlaybackStreamingState';
+import type { ReadonlyPlaybackStreamingState } from './ReadonlyPlaybackStreamingState';
 import { type StreamingEventMap } from '../streaming/StreamingEventMap';
 import type { InferObservableValueType } from '@amazon/vinyl-observable';
-import type { VinylOptions } from '../vinyl/VinylOptions';
+import type { VinylOptions } from './VinylOptions';
+import type { ChangeEvent } from '../event/ChangeEvent';
 /**
  * Events the Vinyl Player emits.
  */
 export interface VinylPlayerEventMap<TrackLoadOptionsType extends TrackLoadOptions = VinylTrackLoadOptions> extends PlaybackControllerEventMap, TrackControllerEventMap<TrackLoadOptionsType>, StreamingEventMap {
+    /**
+     * Dispatched when {@link VinylPlayer.resetPending} changes.
+     *
+     * `current` is true when the player has hit a transient, potentially
+     * recoverable error (e.g. a network outage) and an automatic reset
+     * attempt is scheduled. `current` is false once the pending reset is
+     * emitted, the error is cleared, or all retries are exhausted.
+     *
+     * If `resetPending` becomes false while {@link VinylPlayer.error} is
+     * still non-null, all automatic reset attempts have been exhausted
+     * and playback will not recover without user action.
+     */
+    readonly resetPendingChange: ChangeEvent<boolean>;
 }
 /**
  * A Vinyl Media Player.
@@ -32,6 +46,7 @@ export declare class VinylPlayer<TrackLoadOptionsType extends TrackLoadOptions =
     private get drmController();
     private get playbackController();
     private get trackController();
+    private get autoResetController();
     /**
      * Provides information about the client, such as device and browser capabilities.
      */
@@ -81,6 +96,15 @@ export declare class VinylPlayer<TrackLoadOptionsType extends TrackLoadOptions =
      * The last error reported.
      */
     get error(): Error | null;
+    /**
+     * True when an error has interrupted playback and an automatic reset
+     * is scheduled. This distinguishes transient, potentially recoverable
+     * errors (such as a brief network outage) from terminal errors that
+     * will not trigger a reset on their own.
+     *
+     * Listen to `resetPendingChange` events for changes.
+     */
+    get resetPending(): boolean;
     get hasMetadata(): boolean;
     get loop(): boolean;
     set loop(value: boolean);

package/dist/types/ts4.7/vinyl/createVinylFactories.d.ts

@@ -18,7 +18,7 @@ import { LoudnessNormalizationControllerImpl } from '../playback/loudness/Loudne
 import { AutoResetControllerImpl, type AutoResetControllerImplDeps, type AutoResetControllerImplOptions } from '../track/AutoResetController';
 import type { Dependencies, Factories } from '@amazon/vinyl-di';
 import type { ContentStreamingOptions } from '../streaming/ContentStreamingOptions';
-import { type VinylOptions } from '../vinyl/VinylOptions';
+import { type VinylOptions } from './VinylOptions';
 import type { ObservableValue } from '@amazon/vinyl-observable';
 /**
  * Configuration used by the default dependency factories for Vinyl.
@@ -81,15 +81,13 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
     }) => LoudnessNormalizationControllerImpl;
     capabilities: (deps: CapabilitiesImplDeps) => CapabilitiesImpl;
     requestInterceptor: () => typeof noop;
-    trackFactory: (deps: VinylTrackFactoryDeps) => import("../track/TrackFactory").TrackFactory<import("..").SourceObjectTrackLoadOptions | import("..").SourceTrackLoadOptions | import("..").DashTrackLoadOptions | import("..").HlsTrackLoadOptions>;
+    trackFactory: (deps: VinylTrackFactoryDeps) => import("..").TrackFactory<import("..").SourceObjectTrackLoadOptions | import("..").SourceTrackLoadOptions | import("..").DashTrackLoadOptions | import("..").HlsTrackLoadOptions>;
     trackController: (deps: TrackControllerImplDeps<any>) => TrackControllerImpl<any>;
-    drmKeySystemResolver: () => import("../drm/DrmKeySystemResolver").DrmKeySystemResolver;
+    drmKeySystemResolver: () => import("..").DrmKeySystemResolver;
     drmController: (deps: DrmControllerImplDeps) => DrmControllerImpl;
     commonEme: typeof commonEmeFactory;
     autoResetController: (deps: AutoResetControllerImplDeps) => AutoResetControllerImpl;
-    createDashFactories: (deps: import("../track/dash/createDashFactories").DashFactoryDeps) => (/**
-     * Configuration for segmented streaming tracks (hls / dash).
-     */ loadOptions: import("..").DashTrackLoadOptions) => {
+    createDashFactories: (deps: import("..").DashFactoryDeps) => (loadOptions: import("..").DashTrackLoadOptions) => {
         contentTypesValue: typeof import("..").createDashContentTypesValue;
         baseUrlSelector: () => import("..").BaseUrlSelector;
         segmentRequestInit: () => import("@amazon/vinyl-util").Maybe<Readonly<Omit<RequestInit, "signal">>>;
@@ -112,7 +110,7 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
         contentStreamFactory: typeof import("..").createContentStreamFactory;
         qualitySelector: (deps: {
             options: ObservableValue<Pick<VinylOptions, "abr">>;
-        }) => import("../streaming/abr/QualitySelectorImpl").QualitySelectorImpl;
+        }) => import("..").QualitySelectorImpl;
         manifestTransformed: typeof import("..").createDefaultDashManifestTransformer;
         mediaTimeline: (deps: import("..").BuildDashMediaTimelineDeps & {
             readonly manifestTransformed: ObservableValue<Promise<import("..").DashManifestData>>;
@@ -124,12 +122,12 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
         }>>;
         playbackController: import("@amazon/vinyl-di").Factory<import("..").PlaybackController>;
         playbackSource: import("@amazon/vinyl-di").Factory<import("..").PlaybackSource>;
-        drmKeySystemResolver: import("@amazon/vinyl-di").Factory<import("../drm/DrmKeySystemResolver").DrmKeySystemResolver>;
+        drmKeySystemResolver: import("@amazon/vinyl-di").Factory<import("..").DrmKeySystemResolver>;
         requestInterceptor: import("@amazon/vinyl-di").Factory<import("@amazon/vinyl-util").RequestInterceptor>;
         drmController: import("@amazon/vinyl-di").Factory<import("..").DrmController>;
         capabilities: import("@amazon/vinyl-di").Factory<import("..").Capabilities>;
     };
-    createHlsFactories: (deps: import("../track/hls/createHlsFactories").HlsFactoryDeps) => (loadOptions: import("..").HlsTrackLoadOptions) => {
+    createHlsFactories: (deps: import("..").HlsFactoryDeps) => (loadOptions: import("..").HlsTrackLoadOptions) => {
         contentTypesValue: typeof import("..").createHlsContentTypesValue;
         manifestController: () => import("..").HlsManifestControllerImpl;
         manifestTransformed: typeof import("..").createDefaultHlsManifestTransformer;
@@ -149,7 +147,7 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
         contentStreamFactory: typeof import("..").createContentStreamFactory;
         qualitySelector: (deps: {
             options: ObservableValue<Pick<VinylOptions, "abr">>;
-        }) => import("../streaming/abr/QualitySelectorImpl").QualitySelectorImpl;
+        }) => import("..").QualitySelectorImpl;
         mediaTimeline: (deps: import("..").BuildHlsMediaTimelineDeps & {
             readonly manifestTransformed: ObservableValue<Promise<import("..").HlsManifestData>>;
         }) => ObservableValue<Promise<import("..").MediaTimeline>>;
@@ -160,7 +158,7 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
         }>>;
         playbackController: import("@amazon/vinyl-di").Factory<import("..").PlaybackController>;
         playbackSource: import("@amazon/vinyl-di").Factory<import("..").PlaybackSource>;
-        drmKeySystemResolver: import("@amazon/vinyl-di").Factory<import("../drm/DrmKeySystemResolver").DrmKeySystemResolver>;
+        drmKeySystemResolver: import("@amazon/vinyl-di").Factory<import("..").DrmKeySystemResolver>;
         requestInterceptor: import("@amazon/vinyl-di").Factory<import("@amazon/vinyl-util").RequestInterceptor>;
         drmController: import("@amazon/vinyl-di").Factory<import("..").DrmController>;
         capabilities: import("@amazon/vinyl-di").Factory<import("..").Capabilities>;

package/dist/unit/types/current/streaming/MediaTimeline.test.js

@@ -22,6 +22,7 @@ describe('getMediaPeriodAtTime', () => {
     const timeline = {
         periods: [period1, period2, period3],
         minBufferTime: 2,
+        getDuration: () => Promise.resolve(30),
     };
     it('returns the first period for time 0', () => {
         expect(getMediaPeriodAtTime(timeline, 0)).toBe(period1);
@@ -42,7 +43,11 @@ describe('getMediaPeriodAtTime', () => {
         expect(getMediaPeriodAtTime(timeline, -1)).toBeNull();
     });
     it('returns null for empty timeline', () => {
-        const empty = { periods: [], minBufferTime: 0 };
+        const empty = {
+            periods: [],
+            minBufferTime: 0,
+            getDuration: () => Promise.resolve(0),
+        };
         expect(getMediaPeriodAtTime(empty, 5)).toBeNull();
     });
 });

package/dist/unit/types/current/streaming/MseTrack.test.js

@@ -500,6 +500,7 @@ describe('MseTrack', () => {
                     },
                 ],
                 minBufferTime: 2,
+                getDuration: () => Promise.resolve(Infinity),
             });
             track = createTrack();
             await flushPromises();
@@ -521,6 +522,7 @@ describe('MseTrack', () => {
                     },
                 ],
                 minBufferTime: 2,
+                getDuration: () => Promise.resolve(Infinity),
             });
             track = createTrack();
             const spy = createEventSpy(track, 'qualitiesChange');
@@ -555,6 +557,7 @@ describe('MseTrack', () => {
                     },
                 ],
                 minBufferTime: 2,
+                getDuration: () => Promise.resolve(Infinity),
             };
             setTimeline(timeline);
             track = createTrack();
@@ -587,6 +590,7 @@ describe('MseTrack', () => {
                     },
                 ],
                 minBufferTime: 2,
+                getDuration: () => Promise.resolve(Infinity),
             });
             track = createTrack();
             await flushPromises();

package/dist/unit/types/current/streaming/SegmentControllerImpl.test.js

@@ -76,6 +76,7 @@ describe('SegmentControllerImpl', () => {
                 },
             ],
             minBufferTime: 10,
+            getDuration: () => Promise.resolve(100),
         };
         const mockQualitySelector = {
             selectQuality: () => 0,
@@ -230,6 +231,7 @@ describe('SegmentControllerImpl', () => {
                         },
                     ],
                     minBufferTime: 10,
+                    getDuration: () => Promise.resolve(110),
                 };
                 timelineData.value = Promise.resolve(extendedTimeline);
                 await fillPrefetch();
@@ -330,6 +332,7 @@ describe('SegmentControllerImpl', () => {
                     },
                 ],
                 minBufferTime: 10,
+                getDuration: () => Promise.resolve(100),
             });
             // segmentController is for 'audio', but only 'video' qualities exist
             expect(await segmentController.getSegment(5)).toBeNull();
@@ -582,39 +585,6 @@ describe('SegmentControllerImpl', () => {
             expect(segmentController.startTime).toBe(4);
         });
     });
-    describe('duration', () => {
-        it('delegates to the media timeline', async () => {
-            expect(await segmentController.getDuration()).toBe(100);
-        });
-        it('returns null for empty timeline', async () => {
-            timelineData.value = Promise.resolve({
-                periods: [],
-                minBufferTime: 0,
-            });
-            expect(await segmentController.getDuration()).toBeNull();
-        });
-        it('returns null when last period has Infinity endTime', async () => {
-            timelineData.value = Promise.resolve({
-                periods: [
-                    {
-                        startTime: 0,
-                        endTime: Infinity,
-                        qualities: [],
-                    },
-                ],
-                minBufferTime: 0,
-            });
-            expect(await segmentController.getDuration()).toBeNull();
-        });
-        it('uses getDuration from timeline when provided', async () => {
-            timelineData.value = Promise.resolve({
-                periods: [],
-                minBufferTime: 0,
-                getDuration: () => Promise.resolve(42),
-            });
-            expect(await segmentController.getDuration()).toBe(42);
-        });
-    });
     describe('fetchedTime', () => {
         it('returns the number of seconds currently prefetched', async () => {
             segmentController.configure(defaultConfigOptions);

package/dist/unit/types/current/streaming/abr/QualitySelectorImpl.test.js

@@ -566,6 +566,79 @@ describe('QualitySelectorImpl', () => {
             expect(selector.selectQuality(videoQualities, videoState)).toEqual(0);
         });
     });
+    describe('maxBandwidth', () => {
+        const qualities = [
+            {
+                ...createEmptyMediaQualityMetadata(),
+                bandwidth: 1000,
+                bandwidthTotal: 1000,
+                qualityId: '0',
+            },
+            {
+                ...createEmptyMediaQualityMetadata(),
+                bandwidth: 500,
+                bandwidthTotal: 500,
+                qualityId: '1',
+            },
+            {
+                ...createEmptyMediaQualityMetadata(),
+                bandwidth: 100,
+                bandwidthTotal: 100,
+                qualityId: '2',
+            },
+        ];
+        const prefetchState = {
+            fetchedTime: 0,
+            previousQuality: null,
+            active: false,
+        };
+        beforeEach(() => {
+            // Plenty of bandwidth for the highest quality.
+            metrics.estimatedDownlinkBandwidth.ewmaLow = 5000;
+        });
+        it('caps the selectable quality to the configured bandwidth', () => {
+            options.value = { ...options.value, maxBandwidth: 500 };
+            // Highest quality at or below the cap is index 1 (500).
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(1);
+        });
+        it('falls back to the lowest quality when all exceed the cap', () => {
+            options.value = { ...options.value, maxBandwidth: 50 };
+            // No quality fits — selectQuality falls back to the last (lowest) entry.
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(2);
+        });
+        it('pins to the lowest quality when set to 0', () => {
+            options.value = { ...options.value, maxBandwidth: 0 };
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(2);
+        });
+        it('treats null as no cap', () => {
+            options.value = { ...options.value, maxBandwidth: null };
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(0);
+        });
+        it('does not raise the bandwidth budget above the network estimate', () => {
+            // Network estimate is well below the cap; cap should not raise it.
+            metrics.estimatedDownlinkBandwidth.ewmaLow = 600;
+            options.value = { ...options.value, maxBandwidth: 100_000 };
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(1);
+        });
+        it('has no effect when strategy is LOWEST', () => {
+            options.value = {
+                ...options.value,
+                strategy: AbrStrategy.LOWEST,
+                maxBandwidth: 100_000,
+            };
+            // LOWEST always returns the last index, regardless of the cap.
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(qualities.length - 1);
+        });
+        it('has no effect when strategy is HIGHEST', () => {
+            options.value = {
+                ...options.value,
+                strategy: AbrStrategy.HIGHEST,
+                maxBandwidth: 50,
+            };
+            // HIGHEST always returns 0, regardless of the cap.
+            expect(selector.selectQuality(qualities, prefetchState)).toEqual(0);
+        });
+    });
     describe('toString', () => {
         it('returns a string', () => {
             expect(selector.toString()).toContain('QualitySelectorImpl');

package/dist/unit/types/current/streaming/buffering/BufferingController.test.js

@@ -4,7 +4,7 @@
  */
 import { flushPromises, useMockTime } from '@amazon/vinyl-util/browserTestUtil';
 import { MockMediaSourceController, MockPlaybackController, MockSegmentController, MockSourceBufferController, } from '@amazon/vinyl/vinylTestUtil';
-import { BufferingControllerImpl, clearSourceBufferQuota, createEmptyMediaQualityMetadata, DEFAULT_MAX_APPEND_SIZE, DURATION_PADDING, getSourceBufferQuota, LIVE_DURATION, MIN_APPEND_SIZE, POLL_BUFFER_THROTTLE, QUOTA_REACHED_SCALE, SEGMENT_START_AFFORDANCE, } from '@amazon/vinyl';
+import { BufferingControllerImpl, clearSourceBufferQuota, createEmptyMediaQualityMetadata, DEFAULT_MAX_APPEND_SIZE, getSourceBufferQuota, MIN_APPEND_SIZE, POLL_BUFFER_THROTTLE, QUOTA_REACHED_SCALE, SEGMENT_START_AFFORDANCE, } from '@amazon/vinyl';
 import { Abort, AbortError, Deferred, floorToNearest, LogLevel, } from '@amazon/vinyl-util';
 import { createEventSpy, useMockLogger } from '@amazon/vinyl-util/testUtil';
 var any = jasmine.any;
@@ -86,7 +86,6 @@ describe('BufferingControllerImpl', () => {
     }
     beforeEach(() => {
         mediaSourceController = new MockMediaSourceController();
-        mediaSourceController.duration = Number.NaN;
         playbackController = new MockPlaybackController();
         segmentController = new MockSegmentController();
         segmentController.getSegment.and.callFake((time) => {
@@ -512,45 +511,6 @@ describe('BufferingControllerImpl', () => {
             expect(bufferingController.getBufferedTime()).toBe(10);
         });
     });
-    describe('duration', () => {
-        beforeEach(() => {
-            bufferingController = createBufferingController();
-            bufferingController.activate();
-        });
-        describe('when the media source is open and the segment controller is not updating', () => {
-            it('is set to the segment controller provided value', async () => {
-                segmentController.getDuration.and.resolveTo(33);
-                await open();
-                expect(mediaSourceController.duration).toEqual(33 + DURATION_PADDING);
-            });
-            describe('when segment controller duration resolves to null', () => {
-                it('sets mediaSource duration to LIVE_DURATION', async () => {
-                    segmentController.getDuration.and.resolveTo(null);
-                    await open();
-                    expect(mediaSourceController.duration).toEqual(LIVE_DURATION);
-                });
-            });
-        });
-        describe('when segment controller emits a change event', () => {
-            it('refreshes duration', async () => {
-                segmentController.getDuration.and.resolveTo(42);
-                await open();
-                expect(mediaSourceController.duration).toEqual(42 + DURATION_PADDING);
-                segmentController.getDuration.and.resolveTo(54);
-                segmentController.dispatch('change', {});
-                await nextPollImmediate();
-                expect(mediaSourceController.duration).toEqual(54 + DURATION_PADDING);
-            });
-            describe('and mediaSource is not open', () => {
-                it('does nothing', () => {
-                    // Closed
-                    segmentController.getDuration.and.resolveTo(52);
-                    segmentController.dispatch('change', {});
-                    expect(mediaSourceController.duration).toBeNaN();
-                });
-            });
-        });
-    });
     describe('playbackQuality', () => {
         // The time to simulate a quality change from q1 to q2:
         let changeTime;