@amazon/vinyl 1.1.1 → 1.2.1

package/dist/types/ts4.1/text/parseWebVtt.d.ts

@@ -0,0 +1,60 @@
+import type { VttCueStyle } from './VttCueStyle';
+/**
+ * A single WebVTT cue.
+ *
+ * @see https://www.w3.org/TR/webvtt1/
+ */
+export interface WebVttCue {
+    /**
+     * Optional cue identifier, the line that appears before the timing line.
+     */
+    readonly id: string | null;
+    /**
+     * Cue start time in seconds.
+     */
+    readonly startTime: number;
+    /**
+     * Cue end time in seconds.
+     */
+    readonly endTime: number;
+    /**
+     * The cue text payload, with line breaks preserved as `\n`.
+     */
+    readonly text: string;
+    /**
+     * The authored cue settings from the timing line (position/line/size/
+     * align/vertical), when any were present. Preserved so a renderer can
+     * position the cue faithfully. Absent when the cue declared no settings.
+     */
+    readonly settings?: VttCueStyle;
+}
+/**
+ * The result of parsing a WebVTT document.
+ */
+export interface WebVttDocument {
+    /**
+     * Parsed cues in document order.
+     */
+    readonly cues: readonly WebVttCue[];
+    /**
+     * The raw CSS body of each `STYLE` block, in document order. These carry
+     * `::cue` rules (e.g. `::cue(.loud) { font-weight: bold }`) an HTML renderer
+     * can apply. Empty when the document declared no styles.
+     */
+    readonly styles: readonly string[];
+}
+/**
+ * Parses a WebVTT document into a list of cues.
+ *
+ * Implements a forgiving subset of the WebVTT 1.0 specification: header
+ * detection, comment blocks (lines starting with `NOTE`), styling/region
+ * blocks (STYLE bodies are captured, REGION skipped), cue identifiers, and
+ * HH:MM:SS.mmm or MM:SS.mmm timestamps with optional cue settings.
+ *
+ * @param input The raw WebVTT document text. Both LF and CRLF line endings
+ * are supported, and a leading BOM is stripped if present.
+ * @throws ValidationError if the input is missing the WEBVTT header.
+ * @see https://www.w3.org/TR/webvtt1/#webvtt-timestamp
+ */
+export declare function parseWebVtt(input: string): WebVttDocument;
+//# sourceMappingURL=parseWebVtt.d.ts.map

package/dist/types/ts4.1/text/pickPreferredTextTrack.d.ts

@@ -0,0 +1,15 @@
+import type { TextTrackInfo } from './TextTrack';
+import type { Maybe } from '@amazon/vinyl-util';
+/**
+ * Chooses the text track that best matches the preferred language(s), or null
+ * when none relate (or there is no preference / no tracks).
+ *
+ * Language dominates: a track is ranked first by which preference it relates to
+ * (earlier entries win) and how closely (see {@link languageRelatedness}).
+ * Within a single language, a full track is preferred over a forced-only track
+ * (a user asking for a caption language wants the full captions, not just the
+ * forced foreign-dialogue cues), and a manifest-default track breaks any
+ * remaining tie.
+ */
+export declare function pickPreferredTextTrack(tracks: readonly TextTrackInfo[], preferred: Maybe<string | readonly string[]>): TextTrackInfo | null;
+//# sourceMappingURL=pickPreferredTextTrack.d.ts.map

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/SeekRange.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The seekable time range on the media timeline, in seconds.
+ * `end` will be `Infinity` when a live stream.
+ */
+export type SeekRange = {
+    readonly start: number;
+    readonly end: number;
+};
+//# sourceMappingURL=SeekRange.d.ts.map

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/HlsManifestData.d.ts

@@ -0,0 +1,19 @@
+import type { HlsMainPlaylist, HlsMediaPlaylist } from '@amazon/vinyl-hls-parser';
+export interface HlsManifestData {
+    /**
+     * The main HLS playlist manifest.
+     * Use getMediaPlaylist to resolve bitrate manifests.
+     */
+    readonly mainPlaylist: HlsMainPlaylist;
+    /**
+     * The URL to be used for relative requests. Guaranteed to be absolute.
+     *
+     * Media with relative paths in the manifests will be resolved relative to this URL.
+     */
+    readonly baseUrl: string;
+    /**
+     * Lazily fetches and caches a media playlist by variant URI.
+     */
+    readonly getMediaPlaylist: (uri: string) => Promise<HlsMediaPlaylist>;
+}
+//# sourceMappingURL=HlsManifestData.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/createHlsManifestProvider.d.ts

@@ -0,0 +1,6 @@
+import type { HlsTrackLoadOptions } from './HlsTrack';
+import type { ManifestProvider } from '../../streaming/ManifestController';
+import type { HlsManifestData } from './HlsManifestData';
+export declare function createHlsManifestProvider(loadOptions: HlsTrackLoadOptions): HlsManifestProvider;
+export type HlsManifestProvider = ManifestProvider<HlsManifestData>;
+//# sourceMappingURL=createHlsManifestProvider.d.ts.map

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/inferLoadOptionsFromUri.d.ts

@@ -0,0 +1,15 @@
+import type { VinylTrackLoadOptions } from './createVinylTrackFactories';
+/**
+ * The built-in track types Vinyl can infer from a URI.
+ */
+export type TrackType = 'hls' | 'dash' | 'src';
+/**
+ * Infers the track type from a URI based first on its file extension
+ * then mime type.
+ *
+ * Returns null if the type cannot be determined.
+ */
+export declare function inferTrackTypeFromUrl(url: string): Promise<TrackType | null>;
+export declare function inferTrackTypeFromUrlPath(url: string): TrackType | null;
+export declare function createTrackLoadOptionsFromUrl(url: string): Promise<VinylTrackLoadOptions | null>;
+//# sourceMappingURL=inferLoadOptionsFromUri.d.ts.map

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/util/media/codecOverrides.d.ts

@@ -0,0 +1,33 @@
+/**
+ * An explicit application-provided decision to allow or deny a codec,
+ * bypassing the browser's support detection.
+ *
+ *  - `'allow'` forces the codec to be treated as supported even if the browser
+ *    reports it unsupported (e.g. to opt in to a codec the app knows the
+ *    platform can decode via an external path).
+ *  - `'deny'` forces the codec to be treated as unsupported even if the browser
+ *    reports it supported (e.g. to work around a browser that falsely claims
+ *    support, or to exclude a codec by policy).
+ */
+export type CodecOverride = 'allow' | 'deny';
+/**
+ * Explicit codec allow/deny overrides. Keys are RFC 6381 codec strings or
+ * prefixes (matched case-insensitively against the start of each codec in a
+ * mimeType's `codecs=` list, so `"hvc1"` matches `"hvc1.2.20000000.L123.B0"`).
+ *
+ * An override supersedes the browser's support detection entirely. When a
+ * mimeType contains multiple codecs, a `'deny'` on any of them denies the
+ * mimeType; an `'allow'` applies only when no codec is denied.
+ */
+export type CodecOverrides = Readonly<Record<string, CodecOverride>>;
+/**
+ * Resolves the effective override decision for a mimeType against a set of
+ * {@link CodecOverrides}, or undefined when no override applies (in which case
+ * the caller should fall back to normal support detection).
+ *
+ * A `'deny'` on any contained codec wins over an `'allow'` on another, so an
+ * explicit deny is never silently overridden by an allow elsewhere in the
+ * mimeType.
+ */
+export declare function resolveCodecOverride(mimeType: string, overrides: CodecOverrides | undefined): CodecOverride | undefined;
+//# sourceMappingURL=codecOverrides.d.ts.map

package/dist/types/ts4.1/util/media/codecSupport.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Extracts the individual codec strings from a mimeType's `codecs=` parameter.
+ * Returns an empty array when no codecs parameter is present.
+ */
+export declare function extractCodecs(mimeType: string): string[];
+//# sourceMappingURL=codecSupport.d.ts.map

package/dist/types/ts4.1/util/media/mimeType.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Extracts the container subtype from a MIME type, lowercased — the portion
+ * after the `/`, ignoring any parameters. For example
+ * `video/webm; codecs="vp9"` → `webm` and `audio/mp4` → `mp4`. Returns an empty
+ * string when the MIME type has no subtype.
+ */
+export declare function mimeSubtype(mimeType: string): string;
+//# sourceMappingURL=mimeType.d.ts.map

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.