@amazon/vinyl 1.1.1 → 1.2.0

package/dist/types/ts4.1/track/AutoResetController.d.ts

@@ -1,36 +1,60 @@
 import type { AnyRecord, Clearable, Disposable, ReadonlyEventHost } from '@amazon/vinyl-util';
 import { EventHostImpl } from '@amazon/vinyl-util';
 import type { PlaybackController } from '../playback/PlaybackController';
+import type { 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;
@@ -75,7 +99,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/ts4.1/track/TrackController.d.ts

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

package/dist/types/ts4.1/track/TrackFactory.d.ts

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

package/dist/types/ts4.1/track/createVinylTrackFactories.d.ts

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

package/dist/types/ts4.1/track/dash/DashManifestController.d.ts

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

package/dist/types/ts4.1/track/dash/DashTrack.d.ts

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

package/dist/types/ts4.1/track/dash/buildDashMediaTimeline.d.ts

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

package/dist/types/ts4.1/track/dash/createDashContentTypesValue.d.ts

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

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

@@ -1,12 +1,12 @@
-import type { DashTrackLoadOptions } from '../../track/dash/DashTrack';
+import type { DashTrackLoadOptions } from './DashTrack';
 import type { Maybe, 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 type { MediaSourceControllerImplDeps } from '../../streaming/buffering/MediaSourceController';
 import { MediaSourceControllerImpl } from '../../streaming/buffering/MediaSourceController';
 import type { PlaybackController } from '../../playback/PlaybackController';
-import type { DashManifestController, DashManifestControllerImplDeps } from '../../track/dash/DashManifestController';
+import type { DashManifestController, DashManifestControllerImplDeps } from './DashManifestController';
 import type { DrmKeySystemResolver } from '../../drm/DrmKeySystemResolver';
 import type { DrmController } from '../../drm/DrmController';
 import type { Capabilities } from '../../client/Capabilities';
@@ -15,12 +15,12 @@ import { QualitySelectorImpl } from '../../streaming/abr/QualitySelectorImpl';
 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.
  */
@@ -45,20 +45,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.1/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.1/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.1/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, FilterPredicate, MaybePromise } from '@amazon/vinyl-util';
 /**

package/dist/types/ts4.1/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.1/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.1/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.1/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.1/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.1/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.1/track/mse/MseTrack.d.ts

@@ -1,7 +1,7 @@
-import type { TrackBaseDeps, TrackBaseOptions } from '../../track/TrackBase';
-import { TrackBase } from '../../track/TrackBase';
+import type { TrackBaseDeps, TrackBaseOptions } from '../TrackBase';
+import { TrackBase } from '../TrackBase';
 import type { ReadonlyRanges, 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.1/track/source/FixedPlaybackQuality.d.ts

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

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

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

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

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

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

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

package/dist/types/ts4.1/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.1/vinyl/VinylPlayer.d.ts

@@ -12,14 +12,28 @@ import type { DefaultVinylFactories, InferVinylOverrideDependencyType, VinylDepe
 import type { VinylDeps } from './VinylDeps';
 import type { Capabilities } from '../client/Capabilities';
 import type { ContentType, 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.
@@ -33,6 +47,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.
      */
@@ -75,6 +90,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);

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

@@ -20,7 +20,7 @@ import type { AutoResetControllerImplDeps, AutoResetControllerImplOptions } from
 import { AutoResetControllerImpl } 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.
@@ -83,15 +83,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">>>;
@@ -114,7 +112,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>>;
@@ -126,12 +124,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;
@@ -151,7 +149,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>>;
@@ -162,7 +160,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/types/ts4.7/drm/DrmController.d.ts

@@ -1,9 +1,9 @@
 import { type AnyRecord, type Maybe, type ReadonlyAbort, type ReadonlyEventHost } from '@amazon/vinyl-util';
 import type { DrmInitDataType } from '../streaming/DrmInitDataType';
-import type { DrmKeySystem } from '../drm/DrmKeySystem';
+import type { DrmKeySystem } from './DrmKeySystem';
 import type { MediaFormatMetadata } from '../streaming/MediaQualityMetadata';
 import type { BasicErrorEvent } from '../event/BasicErrorEvent';
-import type { DrmOptions } from '../drm/DrmOptions';
+import type { DrmOptions } from './DrmOptions';
 export interface DrmControllerEventMap {
     /**
      * A DRM error occurred.

package/dist/types/ts4.7/drm/DrmControllerImpl.d.ts

@@ -1,7 +1,7 @@
 import { EventHostImpl, type Maybe, type ReadonlyAbort } from '@amazon/vinyl-util';
-import { type DrmOptions } from '../drm/DrmOptions';
-import type { DrmController, DrmControllerEventMap, DrmKeySystemSupport } from '../drm/DrmController';
-import type { CommonEme, CommonMediaKeyMessageEvent, CommonMediaKeys, CommonMediaKeySession } from '../drm/commonEme/CommonEme';
+import { type DrmOptions } from './DrmOptions';
+import type { DrmController, DrmControllerEventMap, DrmKeySystemSupport } from './DrmController';
+import type { CommonEme, CommonMediaKeyMessageEvent, CommonMediaKeys, CommonMediaKeySession } from './commonEme/CommonEme';
 import type { MediaFormatMetadata } from '../streaming/MediaQualityMetadata';
 /**
  * The number of seconds a license request will be allowed before timing out.

package/dist/types/ts4.7/drm/DrmKeySystemResolver.d.ts

@@ -1,5 +1,5 @@
 import { type ReadonlyRecord } from '@amazon/vinyl-util';
-import { DrmKeySystem } from '../drm/DrmKeySystem';
+import { DrmKeySystem } from './DrmKeySystem';
 /**
  * Given a ContentProtection schemeIdUri, returns the {@link DrmKeySystem} it represents.
  * Not all scheme ids will match to a DrmKeySystem. If none are matched, null is returned.

package/dist/types/ts4.7/drm/DrmOptions.d.ts

@@ -3,7 +3,7 @@ import type { DrmInitDataType } from '../streaming/DrmInitDataType';
 import type { MediaFormatMetadata } from '../streaming/MediaQualityMetadata';
 import { type ObjectSchema, type ValueSchema } from '@amazon/vinyl-validation';
 import { DrmKeySystem } from './DrmKeySystem';
-import { type LicenseProvider, type LicenseServerOptions } from '../drm/licenseProvider/LicenseProvider';
+import { type LicenseProvider, type LicenseServerOptions } from './licenseProvider/LicenseProvider';
 /**
  * DrmRobustness is the requested security level for audio or video decryption.
  */

package/dist/types/ts4.7/drm/commonEme/CommonEme.d.ts

@@ -2,10 +2,10 @@
  * An common interface to unify multiple EME implementations.
  * @module
  */
-import type { DrmKeySystem } from '../../drm/DrmKeySystem';
+import type { DrmKeySystem } from '../DrmKeySystem';
 import type { Json, ReadonlyEventHost, Unsubscribe } from '@amazon/vinyl-util';
 import { ReportableError } from '@amazon/vinyl-util';
-import type { EncryptedInitData } from '../../drm/commonEme/EncryptedInitData';
+import type { EncryptedInitData } from './EncryptedInitData';
 import type { DrmInitDataType } from '../../streaming/DrmInitDataType';
 import type { BasicErrorEvent } from '../../event/BasicErrorEvent';
 /**

package/dist/types/ts4.7/drm/commonEme/CommonEmeFactory.d.ts

@@ -1,4 +1,4 @@
-import type { CommonEme } from '../../drm/commonEme/CommonEme';
+import type { CommonEme } from './CommonEme';
 /**
  * Common EME Factory provides the first supported implementation of CommonEme.
  * The priority is WebKit, Standard, then MS.

package/dist/types/ts4.7/drm/commonEme/MsCommonEme.d.ts

@@ -1,6 +1,6 @@
 import { type Disposable, EventHostImpl, type Unsubscribe } from '@amazon/vinyl-util';
 import { type CommonEme, type CommonMediaKeys, type CommonMediaKeySession, type CommonMediaKeySessionEventMap, type CommonMediaKeySystemAccess, MediaKeySessionErrorType } from './CommonEme';
-import type { DrmKeySystem } from '../../drm/DrmKeySystem';
+import type { DrmKeySystem } from '../DrmKeySystem';
 import { type EncryptedInitData } from './EncryptedInitData';
 import type { DrmInitDataType } from '../../streaming/DrmInitDataType';
 declare global {

package/dist/types/ts4.7/drm/commonEme/StandardCommonEme.d.ts

@@ -1,6 +1,6 @@
 import { type Disposable, EventHostImpl, type Unsubscribe } from '@amazon/vinyl-util';
 import type { CommonEme, CommonMediaEncryptedEvent, CommonMediaKeys, CommonMediaKeySession, CommonMediaKeySessionEventMap, CommonMediaKeySystemAccess } from './CommonEme';
-import type { DrmKeySystem } from '../../drm/DrmKeySystem';
+import type { DrmKeySystem } from '../DrmKeySystem';
 import { type EncryptedInitData } from './EncryptedInitData';
 import type { DrmInitDataType } from '../../streaming/DrmInitDataType';
 /**