@amazon/vinyl 1.1.1 → 1.2.0

package/dist/types/ts3.7/streaming/buffering/BufferingController.d.ts

@@ -1,17 +1,11 @@
 import { AnyRecord, Clearable, Disposable, EventHostImpl, ReadonlyEventHost } from '@amazon/vinyl-util';
 import { ReadonlyPlaybackController } from '../../playback/ReadonlyPlaybackController';
 import { SourceBufferController } from './SourceBufferController';
-import { ReadonlySegmentController } from '../../streaming/SegmentController';
+import { ReadonlySegmentController } from '../SegmentController';
 import { BasicErrorEvent } from '../../event/BasicErrorEvent';
 import { ChangeEvent } from '../../event/ChangeEvent';
-import { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
-import { MediaSourceController } from '../../streaming/buffering/MediaSourceController';
-/**
- * Chrome 52 has decoding errors when duration is set to the mediaPresentationDuration.
- * Adds a slight padding as a workaround.
- * @private
- */
-export declare const DURATION_PADDING = 0.1;
+import { ContentType, MediaQualityMetadata } from '../MediaQualityMetadata';
+import { MediaSourceController } from './MediaSourceController';
 /**
  * The interval to throttle polling the buffer.
  * Reset after a seek.
@@ -167,10 +161,6 @@ export declare class BufferingControllerImpl extends EventHostImpl<BufferingCont
     deactivate(): void;
     reset(): void;
     get busy(): boolean;
-    /**
-     * Enqueues a duration update.
-     */
-    private refreshDuration;
     /**
      * Resets the throttle and polls the buffer on the next frame.
      */

package/dist/types/ts3.7/streaming/buffering/MediaSourceController.d.ts

@@ -1,7 +1,15 @@
 import { AnyRecord, Disposable, EventHostImpl, Json, LogTarget, ReadonlyEventHost, ReportableError } from '@amazon/vinyl-util';
-import { ContentTypesValue } from '../../streaming/ContentTypesValue';
+import { ObservableValue } from '@amazon/vinyl-observable';
+import { ContentTypesValue } from '../ContentTypesValue';
 import { BasicErrorEvent } from '../../event/BasicErrorEvent';
-import { ContentType } from '../../streaming/MediaQualityMetadata';
+import { ContentType } from '../MediaQualityMetadata';
+import { MediaTimeline } from '../MediaTimeline';
+/**
+ * Chrome 52 has decoding errors when duration is set to the mediaPresentationDuration.
+ * Adds a slight padding as a workaround.
+ * @private
+ */
+export declare const DURATION_PADDING = 0.1;
 export interface SourceBufferRef extends Disposable {
     /**
      * The source buffer.
@@ -22,7 +30,8 @@ export interface MediaSourceControllerEventMap {
      */
     readonly sourceOpen: AnyRecord;
     /**
-     * All source buffers have been created and data may be appended.
+     * All source buffers have been created, the media source duration has been set, and data
+     * may be appended.
      */
     readonly readyToAppend: AnyRecord;
     /**
@@ -35,20 +44,12 @@ export interface ReadonlyMediaSourceController extends ReadonlyEventHost<MediaSo
      * Returns the parent media source ready state.
      */
     readonly readyState: ReadyState;
-    /**
-     * Gets the media source's duration.
-     */
-    readonly duration: number;
     /**
      * True if all source buffers have been created and data may be appended.
      */
     readonly readyToAppend: boolean;
 }
 export interface MediaSourceController extends ReadonlyMediaSourceController {
-    /**
-     * Sets/gets the media source's duration.
-     */
-    duration: number;
     /**
      * Constructs a new SourceBuffer with the given content type and mime type.
      */
@@ -72,21 +73,46 @@ export interface MediaSourceControllerImplDeps {
      * Provides the streams that must be created before appending.
      */
     readonly contentTypesValue: ContentTypesValue;
+    /**
+     * The media timeline used to determine duration.
+     */
+    readonly mediaTimelineTransformed: ObservableValue<Promise<MediaTimeline>>;
 }
 export declare class MediaSourceControllerImpl extends EventHostImpl<MediaSourceControllerEventMap> implements MediaSourceController, LogTarget {
+    private readonly deps;
     get [Symbol.toStringTag](): string;
-    private sourceBufferCount;
+    private readonly sourceBuffers;
     private readonly mediaSource;
     private readonly disposer;
     private contentTypes;
+    private durationSet;
+    /**
+     * Token for the in-flight duration update; used to discard stale results when
+     * the timeline changes or the source closes mid-fetch.
+     */
+    private durationToken;
     constructor(deps: MediaSourceControllerImplDeps);
+    private get sourceBufferCount();
+    private readonly errorHandler;
+    /**
+     * Subscription to mediaTimelineTransformed; only attached while the media source is open
+     * so the timeline pipeline isn't forced to evaluate before the source has opened.
+     */
+    private timelineSub;
     private initializeEvents;
-    get duration(): number;
-    set duration(value: number);
+    /**
+     * Sets the duration on the media source from the current media timeline.
+     * Live streams use LIVE_DURATION since not all browsers support +Infinity duration.
+     *
+     * MSE throws InvalidStateError if duration is set while any source buffer is updating,
+     * so we wait for all tracked source buffers to be idle first.
+     */
+    private refreshDuration;
     get readyState(): ReadyState;
     createSourceBuffer(contentType: ContentType, mimeType: string): SourceBufferRef;
     /**
-     * Emits a 'readyToAppend' event if all source buffers have been created.
+     * Emits a 'readyToAppend' event if all source buffers have been created and the duration
+     * has been applied to the media source.
      */
     private readonly checkReady;
     endOfStream(error?: EndOfStreamError): void;

package/dist/types/ts3.7/streaming/buffering/SourceBufferController.d.ts

@@ -1,6 +1,6 @@
 import { Disposable, LogTarget, ReadonlyRanges, Task } from '@amazon/vinyl-util';
 import { MediaSourceController } from './MediaSourceController';
-import { ContentType } from '../../streaming/MediaQualityMetadata';
+import { ContentType } from '../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;

package/dist/types/ts3.7/streaming/createDefaultMediaTimelineTransformer.d.ts

@@ -1,7 +1,7 @@
 import { ObservableValue } from '@amazon/vinyl-observable';
 import { Capabilities } from '../client/Capabilities';
 import { DrmController } from '../drm/DrmController';
-import { MediaTimeline } from '../streaming/MediaTimeline';
+import { MediaTimeline } from './MediaTimeline';
 export interface DefaultMediaTimelineTransformerDeps {
     readonly capabilities: Capabilities;
     readonly drmController: DrmController;

package/dist/types/ts3.7/streaming/mediaTimelineFilter.d.ts

@@ -1,5 +1,5 @@
-import { MediaTimeline } from '../streaming/MediaTimeline';
-import { MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { MediaTimeline } from './MediaTimeline';
+import { MediaQualityMetadata } from './MediaQualityMetadata';
 import { FilterPredicate, FilterPredicateAsync, Maybe } from '@amazon/vinyl-util';
 /**
  * Filters qualities in a MediaTimeline using a synchronous predicate.
@@ -14,5 +14,5 @@ export declare function filterTimelineQualitiesAsync(filter: FilterPredicateAsyn
 /**
  * Creates a language filter predicate for use with filterTimelineQualities.
  */
-export { createLanguageFilter } from '../streaming/mediaTimelineLanguageFilter';
+export { createLanguageFilter } from './mediaTimelineLanguageFilter';
 //# sourceMappingURL=mediaTimelineFilter.d.ts.map

package/dist/types/ts3.7/streaming/mediaTimelineLanguageFilter.d.ts

@@ -1,4 +1,4 @@
-import { MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
+import { MediaQualityMetadata } from './MediaQualityMetadata';
 import { FilterPredicate } from '@amazon/vinyl-util';
 /**
  * Creates a filter predicate that keeps qualities matching the preferred language.

package/dist/types/ts3.7/streaming/util/segment.d.ts

@@ -1,4 +1,4 @@
-import { MediaSegmentMetadata } from '../../streaming/SegmentReference';
+import { MediaSegmentMetadata } from '../SegmentReference';
 /**
  * Returns the segment whose range covers `time` (`startTime <= time < endTime`), or
  * — when `affordance > 0` — the next segment if `time` falls within `affordance`

package/dist/types/ts3.7/track/AutoResetController.d.ts

@@ -1,35 +1,59 @@
 import { AnyRecord, Clearable, Disposable, EventHostImpl, ReadonlyEventHost } from '@amazon/vinyl-util';
 import { PlaybackController } from '../playback/PlaybackController';
+import { ChangeEvent } from '../event/ChangeEvent';
 export interface AutoResetControllerEventMap {
     /**
      * Notifies that playback errors should be reset and retried.
      */
     readonly reset: AnyRecord;
+    /**
+     * Dispatched when {@link AutoResetController.resetPending} changes.
+     */
+    readonly resetPendingChange: ChangeEvent<boolean>;
 }
 /**
- * Notifies when playback should be reset and retried.
+ * Notifies when playback should be reset and retried after a transient,
+ * potentially-recoverable error.
  *
- * The controller monitors for retry opportunities after an error is set:
- * - Immediately on network 'online' events
- * - After a timeout interval if online
+ * Once an eligible error is set, the controller watches for opportunities
+ * to emit a `reset` event:
+ * - Immediately when the network transitions back to online
+ * - After a timeout interval, if online and retries are not exhausted
  * - Immediately on user playback actions (play, pause, seeking, playing)
  *
- * Each error triggers a single timeout. If another error occurs after a reset,
- * setError() should be called again to schedule the next retry attempt.
+ * Each error triggers a single retry timeout. If another error occurs
+ * after a reset, {@link AutoResetController.setError} should be called again
+ * to schedule the next retry attempt.
  */
 export interface AutoResetController extends ReadonlyEventHost<AutoResetControllerEventMap>, Clearable {
     /**
-     * Sets the current playback error and begins monitoring for retry opportunities.
+     * Sets the current playback error and, if eligible, begins watching for
+     * retry opportunities.
+     *
+     * An error is eligible when it is a {@link RequestError} that did not
+     * receive an HTTP response (i.e. `response == null`), indicating a
+     * transient network failure such as connection loss or DNS failure.
+     * All other errors — including HTTP failures with a response (4xx/5xx),
+     * and non-RequestError errors — are ignored, since those are unlikely
+     * to recover on their own.
      *
-     * Only SERVICE_INTERNAL ReportableErrors are monitored. Subsequent calls while
-     * an error is already set are ignored until the error is cleared via reset or clear().
+     * Subsequent calls while an error is already set are ignored until the
+     * error is cleared via a reset emission or {@link Clearable.clear}.
      *
-     * After a reset, if another error occurs, this method should be called again
-     * to schedule the next retry attempt.
+     * After a reset, if another eligible error occurs, this method should
+     * be called again to schedule the next retry attempt.
      *
      * @param error The error to monitor for retry opportunities
      */
     setError(error: Error): void;
+    /**
+     * True while an eligible error is being watched and a `reset` event
+     * may still be emitted. Becomes false once the error is cleared, a
+     * reset is emitted, or all retries are exhausted.
+     *
+     * Listen to `resetPendingChange` events for changes.
+     */
+    readonly resetPending: boolean;
 }
 export interface AutoResetControllerImplDeps {
     readonly playbackController: PlaybackController;
@@ -74,7 +98,8 @@ export declare class AutoResetControllerImpl extends EventHostImpl<AutoResetCont
     private disposer;
     constructor(deps: AutoResetControllerImplDeps, options?: Partial<AutoResetControllerImplOptions>);
     setError(error: Error): void;
-    private setWatching;
+    get resetPending(): boolean;
+    private setResetPending;
     private reset;
     clear(): void;
     get disposed(): boolean;

package/dist/types/ts3.7/track/TrackController.d.ts

@@ -1,7 +1,7 @@
 import { AnyRecord, Disposable, EventHostImpl, Maybe, ReadonlyEventHost } from '@amazon/vinyl-util';
 import { PlaybackController } from '../playback/PlaybackController';
-import { ReadonlyTrack, TrackUri } from '../track/Track';
-import { TrackFactory, TrackLoadOptions } from '../track/TrackFactory';
+import { ReadonlyTrack, TrackUri } from './Track';
+import { TrackFactory, TrackLoadOptions } from './TrackFactory';
 import { ChangeEvent } from '../event/ChangeEvent';
 export interface TrackControllerEventMap<TrackLoadOptionsType extends TrackLoadOptions> {
     /**

package/dist/types/ts3.7/track/TrackFactory.d.ts

@@ -1,6 +1,6 @@
 import { AnyRecord, Maybe, ReadonlyRecord } from '@amazon/vinyl-util';
 import { ObjectSchema } from '@amazon/vinyl-validation';
-import { Track, TrackTypeId, TrackUri } from '../track/Track';
+import { Track, TrackTypeId, TrackUri } from './Track';
 export interface TrackLoadOptions {
     /**
      * The track type, used to map to a track factory.

package/dist/types/ts3.7/track/createVinylTrackFactories.d.ts

@@ -1,8 +1,8 @@
-import { SourceObjectTrackDeps, SourceObjectTrackLoadOptions } from '../track/source/SourceObjectTrack';
-import { SourceTrackDeps, SourceTrackLoadOptions } from '../track/source/SourceTrack';
-import { TrackFactory } from '../track/TrackFactory';
-import { DashTrackFactoryDeps, DashTrackLoadOptions } from '../track/dash/DashTrack';
-import { HlsTrackFactoryDeps, HlsTrackLoadOptions } from '../track/hls/HlsTrack';
+import { SourceObjectTrackDeps, SourceObjectTrackLoadOptions } from './source/SourceObjectTrack';
+import { SourceTrackDeps, SourceTrackLoadOptions } from './source/SourceTrack';
+import { TrackFactory } from './TrackFactory';
+import { DashTrackFactoryDeps, DashTrackLoadOptions } from './dash/DashTrack';
+import { HlsTrackFactoryDeps, HlsTrackLoadOptions } from './hls/HlsTrack';
 export interface VinylTrackFactoryDeps extends SourceTrackDeps, SourceObjectTrackDeps, DashTrackFactoryDeps, HlsTrackFactoryDeps {
 }
 export type VinylTrackLoadOptions = SourceObjectTrackLoadOptions | SourceTrackLoadOptions | DashTrackLoadOptions | HlsTrackLoadOptions;

package/dist/types/ts3.7/track/dash/DashManifestController.d.ts

@@ -1,4 +1,4 @@
-import { DashManifestData, DashManifestProvider } from '../../track/dash/DashManifestProvider';
+import { DashManifestData, DashManifestProvider } from './DashManifestProvider';
 import { ManifestController } from '../../streaming/ManifestController';
 export type DashManifestController = ManifestController<Promise<DashManifestData>>;
 export interface DashManifestControllerImplDeps {

package/dist/types/ts3.7/track/dash/DashTrack.d.ts

@@ -1,12 +1,12 @@
-import { TrackBaseOptions } from '../../track/TrackBase';
+import { TrackBaseOptions } from '../TrackBase';
 import { DashManifestProvider, DashManifestData } from './DashManifestProvider';
 import { DashManifestController } from './DashManifestController';
-import { TrackFactory, TrackLoadOptions } from '../../track/TrackFactory';
+import { TrackFactory, TrackLoadOptions } from '../TrackFactory';
 import { ObservableValue } from '@amazon/vinyl-observable';
 import { Maybe, RequestInitOptions } from '@amazon/vinyl-util';
 import { Factories } from '@amazon/vinyl-di';
-import { DashMediaQualityMetadataResolver } from '../../track/dash/DashMediaQualityMetadataResolver';
-import { MseTrackDeps } from '../../track/mse/MseTrack';
+import { DashMediaQualityMetadataResolver } from './DashMediaQualityMetadataResolver';
+import { MseTrackDeps } from '../mse/MseTrack';
 import { MediaTimeline } from '../../streaming/MediaTimeline';
 export interface DashTrackLoadOptions extends TrackLoadOptions {
     readonly type: 'dash';

package/dist/types/ts3.7/track/dash/buildDashMediaTimeline.d.ts

@@ -1,6 +1,6 @@
-import { DashManifestData } from '../../track/dash/DashManifestProvider';
+import { DashManifestData } from './DashManifestProvider';
 import { MediaTimeline } from '../../streaming/MediaTimeline';
-import { DashSegmentProviderDeps } from '../../track/dash/timeline/DashRepresentationSegmentProvider';
+import { DashSegmentProviderDeps } from './timeline/DashRepresentationSegmentProvider';
 export type BuildDashMediaTimelineDeps = DashSegmentProviderDeps;
 /**
  * Builds a MediaTimeline from a Dash manifest.

package/dist/types/ts3.7/track/dash/createDashContentTypesValue.d.ts

@@ -1,5 +1,5 @@
-import { DashManifestData } from '../../track/dash/DashManifestProvider';
-import { DashMediaQualityMetadataResolver } from '../../track/dash/DashMediaQualityMetadataResolver';
+import { DashManifestData } from './DashManifestProvider';
+import { DashMediaQualityMetadataResolver } from './DashMediaQualityMetadataResolver';
 import { ContentTypesValue } from '../../streaming/ContentTypesValue';
 import { ObservableValue } from '@amazon/vinyl-observable';
 export interface DashContentTypesValueDeps {

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

@@ -1,11 +1,11 @@
-import { DashTrackLoadOptions } from '../../track/dash/DashTrack';
+import { DashTrackLoadOptions } from './DashTrack';
 import { Maybe, RequestInterceptor } from '@amazon/vinyl-util';
-import { createDefaultDashManifestTransformer } from '../../track/dash/createDefaultDashManifestTransformer';
+import { createDefaultDashManifestTransformer } from './createDefaultDashManifestTransformer';
 import { createMediaSource } from '../../util/media/mediaSource';
-import { DashMediaQualityMetadataResolverDeps } from '../../track/dash/DashMediaQualityMetadataResolver';
+import { DashMediaQualityMetadataResolverDeps } from './DashMediaQualityMetadataResolver';
 import { MediaSourceControllerImpl, MediaSourceControllerImplDeps } from '../../streaming/buffering/MediaSourceController';
 import { PlaybackController } from '../../playback/PlaybackController';
-import { DashManifestController, DashManifestControllerImplDeps } from '../../track/dash/DashManifestController';
+import { DashManifestController, DashManifestControllerImplDeps } from './DashManifestController';
 import { DrmKeySystemResolver } from '../../drm/DrmKeySystemResolver';
 import { DrmController } from '../../drm/DrmController';
 import { Capabilities } from '../../client/Capabilities';
@@ -13,12 +13,12 @@ import { QualitySelectorImpl, QualitySelectorImplOptions } from '../../streaming
 import { PlaybackSource } from '../../playback/PlaybackSource';
 import { createContentStreamFactory } from '../../streaming/ContentStream';
 import { ContentStreamingOptions } from '../../streaming/ContentStreamingOptions';
-import { createDashContentTypesValue } from '../../track/dash/createDashContentTypesValue';
+import { createDashContentTypesValue } from './createDashContentTypesValue';
 import { ObservableValue } from '@amazon/vinyl-observable';
 import { VinylOptions } from '../../vinyl/VinylOptions';
-import { BuildDashMediaTimelineDeps } from '../../track/dash/buildDashMediaTimeline';
+import { BuildDashMediaTimelineDeps } from './buildDashMediaTimeline';
 import { createDefaultMediaTimelineTransformer } from '../../streaming/createDefaultMediaTimelineTransformer';
-import { DashManifestData } from '../../track/dash/DashManifestProvider';
+import { 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/ts3.7/track/dash/createDashManifestProvider.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,7 +1,7 @@
 import { HlsSegment } from '@amazon/vinyl-hls-parser';
 import { MediaSegmentReference } from '../../../streaming/SegmentReference';
 import { SegmentDataProvider } from '../../../streaming/SegmentDataSlot';
-import { CreateSegmentDataProviderDeps } from '../../../track/createSegmentDataProvider';
+import { 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/ts3.7/track/mse/MseTrack.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

@@ -11,14 +11,28 @@ import { DefaultVinylFactories, InferVinylOverrideDependencyType, VinylDependenc
 import { VinylDeps } from './VinylDeps';
 import { Capabilities } from '../client/Capabilities';
 import { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
-import { ReadonlyPlaybackStreamingState } from '../vinyl/ReadonlyPlaybackStreamingState';
+import { ReadonlyPlaybackStreamingState } from './ReadonlyPlaybackStreamingState';
 import { StreamingEventMap } from '../streaming/StreamingEventMap';
 import { InferObservableValueType } from '@amazon/vinyl-observable';
-import { VinylOptions } from '../vinyl/VinylOptions';
+import { VinylOptions } from './VinylOptions';
+import { 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.
      */
@@ -74,6 +89,7 @@ export declare class VinylPlayer<TrackLoadOptionsType extends TrackLoadOptions =
     get duration(): number;
     get ended(): boolean;
     get error(): (Error | null);
+    get resetPending(): boolean;
     get hasMetadata(): boolean;
     get loop(): boolean;
     set loop(value: boolean);