@amazon/vinyl 1.1.1 → 1.2.1

package/dist/types/ts3.7/ad/AdController.d.ts

@@ -0,0 +1,243 @@
+import { ChangeEvent } from '../event/ChangeEvent';
+import { ReadonlyEventHost } from '@amazon/vinyl-util';
+import { AdBreakInfo, AdInfo, TrackAds } from './AdBreakInfo';
+import { AdsProvider } from './AdsProvider';
+/**
+ * Events dispatched by an {@link AdController}. These are provider-agnostic:
+ * an application listens once and receives the same events whether the ads
+ * originate from HLS Interstitials or DASH SCTE-35.
+ */
+export interface AdEventMap {
+    /**
+     * Emitted when the set of known ad breaks for the current media changes,
+     * for example when a live manifest reveals a new break.
+     */
+    readonly currentTrackAdsChange: ChangeEvent<TrackAds | null>;
+    /**
+     * Dispatched when the playhead approaches a midroll or postroll break —
+     * within the break's resolution/preload window — so its ad assets can be
+     * resolved and warmed ahead of entry. Fires once per break as it is
+     * approached (again after a seek back re-arms a replayable break). Prerolls
+     * are preloaded up front and do not emit this.
+     */
+    readonly adPreload: AdBreakEvent;
+    /**
+     * Dispatched when an ad break has been entered — its ads may still be
+     * resolving. An ad break may contain one or more ads.
+     */
+    readonly adBreakEntered: AdBreakEvent;
+    /**
+     * Dispatched when the current ad break has completed: all of its ads
+     * played, were skipped, it hit its playout limit, or it had no ads. Carries
+     * the position at which primary content resumes.
+     */
+    readonly adBreakCompleted: AdBreakCompleteEvent;
+    /**
+     * Dispatched when an ad region has been entered.
+     */
+    readonly adEntered: AdEvent;
+    /**
+     * Dispatched when an ad has started playing.
+     */
+    readonly adPlaying: AdEvent;
+    /**
+     * Dispatched on each playback progress tick while an ad is active, carrying
+     * the elapsed and remaining time for both the current ad and the whole ad
+     * break. Applications should prefer this over deriving ad timing from the
+     * media element's duration.
+     */
+    readonly adTimeUpdate: AdTimeUpdateEvent;
+    /**
+     * Dispatched when an ad has played through 25%.
+     */
+    readonly adFirstQuartile: AdProgressEvent;
+    /**
+     * Dispatched when an ad has played through 50%.
+     */
+    readonly adMidpoint: AdProgressEvent;
+    /**
+     * Dispatched when an ad has played through 75%.
+     */
+    readonly adThirdQuartile: AdProgressEvent;
+    /**
+     * Dispatched when an ad has played through 100%.
+     * Will be dispatched before adCompleted.
+     */
+    readonly adEnded: AdProgressEvent;
+    /**
+     * Dispatched when an ad has stopped playing for any reason such as
+     * ended, error, or skipped.
+     */
+    readonly adCompleted: AdCompleteEvent;
+    /**
+     * An ad list or an individual ad failed to complete.
+     */
+    readonly adError: AdErrorEvent;
+}
+export interface AdErrorEvent {
+    /**
+     * The current ad break when the ad failed to load.
+     */
+    readonly adBreak: AdBreakInfo;
+    /**
+     * If set, the error was from an individual ad.
+     * If not set, the failure was in loading the ad list.
+     */
+    readonly currentAd: AdInfo | null;
+    /**
+     * The source error.
+     */
+    readonly error: any;
+}
+export interface AdEvent {
+    /** The parent ad break */
+    readonly adBreak: AdBreakInfo;
+    /** The ad that triggered this event. */
+    readonly ad: AdInfo;
+    /** The zero-based position of this ad within its break. */
+    readonly index: number;
+    /** The total number of ads in this break. */
+    readonly totalAds: number;
+}
+export interface AdProgressEvent extends AdEvent {
+    /**
+     * The average continuous playback rate for the quartile.
+     * Typically, 1.0 unless playbackRate was altered.
+     */
+    readonly playbackRateAvg: number;
+}
+export interface AdTimeUpdateEvent extends AdEvent {
+    /** Seconds the current ad has played. */
+    readonly adCurrentTime: number;
+    /**
+     * Seconds remaining in the current ad, or null when the ad's duration is
+     * unknown.
+     */
+    readonly adTimeRemaining: number | null;
+    /**
+     * Seconds the current ad break has played, summed across all of its ads so
+     * far (including the current one).
+     */
+    readonly breakCurrentTime: number;
+    /**
+     * Seconds remaining in the current ad break as a whole, or null when the
+     * break's total duration is unknown.
+     */
+    readonly breakTimeRemaining: number | null;
+    /**
+     * Whether the current ad may be skipped right now — false while skipping is
+     * restricted or the break's skip window has not yet opened. Applications
+     * should gate their skip control on this.
+     */
+    readonly canSkip: boolean;
+    /**
+     * Seconds until the ad becomes skippable, or null when there is no pending
+     * skip window (it is already skippable, or skipping is never offered).
+     */
+    readonly skipIn: number | null;
+}
+export interface AdCompleteEvent extends AdEvent {
+    /** The current ad break. */
+    readonly adBreak: AdBreakInfo;
+    /** The reason the ad changed, e.g. 'ended' for completed naturally, or 'skipped' */
+    readonly reason: AdChangeReason;
+}
+export interface AdBreakEvent {
+    /** The ad break. */
+    readonly adBreak: AdBreakInfo;
+}
+export interface AdBreakCompleteEvent extends AdBreakEvent {
+    /**
+     * The absolute media-timeline position, in seconds, at which primary content
+     * resumes after this break. The controller has already resolved the break's
+     * resume offset and playout, so consumers use this position directly.
+     */
+    readonly resumePosition: number;
+    /** The reason the ad break changed, e.g. 'ended' for completed naturally, or 'skipped' */
+    readonly reason: AdChangeReason;
+}
+export type AdChangeReason = 'ended' | 'skipped' | 'contentChange' | 'error';
+export declare const ALL_AD_EVENTS: readonly [
+    "currentTrackAdsChange",
+    "adPreload",
+    "adBreakEntered",
+    "adBreakCompleted",
+    "adFirstQuartile",
+    "adEntered",
+    "adPlaying",
+    "adTimeUpdate",
+    "adMidpoint",
+    "adThirdQuartile",
+    "adEnded",
+    "adCompleted",
+    "adError"
+];
+/**
+ * Read-only view of the ad breaks for the current media and which break, if
+ * any, currently contains the playhead.
+ */
+export interface ReadonlyAdController extends ReadonlyEventHost<AdEventMap> {
+    /**
+     * The ad breaks known for the current media.
+     */
+    readonly currentTrackAds: TrackAds | null;
+    /**
+     * The ad break currently containing the playhead, or null when the
+     * playhead is in primary content.
+     */
+    readonly currentAdBreak: AdBreakInfo | null;
+    /**
+     * The ad currently playing within the active break, or null.
+     */
+    readonly currentAd: AdInfo | null;
+}
+/**
+ * Tracks the ad breaks for the current media and reports when the playhead
+ * enters and exits them.
+ *
+ * The controller is deliberately agnostic of HLS/DASH discovery details: its
+ * input is a list of {@link AdBreakInfo} sourced from an {@link AdsProvider}
+ * (set via {@link setAdsProvider}); it derives the active break from the
+ * playhead by observing the playback controller.
+ */
+export interface AdController extends ReadonlyAdController {
+    /**
+     * Sets the source of ad breaks, or null when no source is active. A
+     * `ReadonlyTrack` satisfies {@link AdsProvider} directly, so the current
+     * playing track can be passed as-is.
+     */
+    setAdsProvider(provider: AdsProvider | null): void;
+    /**
+     * Skips the entire active ad break, advancing past all remaining ads.
+     * No-op when no ad break is active.
+     */
+    skipAdBreak(): void;
+    /**
+     * Skips the currently playing ad. If there are more ads in the break,
+     * the next ad begins. If it's the last ad, the break ends.
+     * No-op when no ad break is active.
+     */
+    skipAd(): void;
+    /**
+     * Skips the current ad with 'error' for the completed reason.
+     * Emits an 'adError' event.
+     * If there are more ads in the break,
+     * the next ad begins. If it's the last ad, the break ends.
+     *
+     * No-op when no ad break is active.
+     */
+    failAd(error: Error): void;
+    /**
+     * Activates the preroll ads.
+     * Does nothing if there is no preroll.
+     * Resolves with the active preroll, or null if there wasn't one.
+     */
+    enterPreroll(): Promise<AdBreakInfo | null>;
+    /**
+     * Activates the next postroll ad.
+     * Does nothing if there is no postroll.
+     * Resolves with the active postroll, or null if there wasn't one.
+     */
+    enterPostroll(): Promise<AdBreakInfo | null>;
+}
+//# sourceMappingURL=AdController.d.ts.map

package/dist/types/ts3.7/ad/AdControllerImpl.d.ts

@@ -0,0 +1,146 @@
+import { EventHostImpl } from '@amazon/vinyl-util';
+import { AdBreakInfo, AdInfo, TrackAds } from './AdBreakInfo';
+import { AdController, AdEventMap } from './AdController';
+import { ReadonlyPlaybackController } from '../playback/ReadonlyPlaybackController';
+import { AdsProvider } from './AdsProvider';
+/**
+ * The % playhead start tolerance for playback progress when emitting ad progress events.
+ */
+export declare const AD_START_TOLERANCE = 0.05;
+export interface AdControllerImplDeps {
+    readonly playbackController: ReadonlyPlaybackController;
+}
+export interface AdControllerImplOptions {
+    /**
+     * After an ad is set, the number of seconds to wait for playback to begin
+     * before marking the ad as failed.
+     * Default: 15
+     */
+    readonly adLoadTimeout: number;
+    /**
+     * How many seconds ahead of a midroll or postroll break to emit `adPreload`
+     * (so its ad assets can be warmed before the playhead reaches it). Used only
+     * when the break itself carries no {@link AdBreakInfo.resolutionTimeOffset};
+     * a break's own offset always takes precedence.
+     * Default: 10
+     */
+    readonly preloadAheadTime: number;
+}
+export declare const defaultAdControllerImplOptions: AdControllerImplOptions;
+/**
+ * Provider-agnostic {@link AdController}. Holds the discovered ad breaks and
+ * derives enter/exit region events from playhead time updates.
+ *
+ * This controller is the *model* for ad playback: it knows which breaks exist,
+ * which break contains the playhead, and which ad within that break is current.
+ * It does NOT create, preload, or activate any tracks — that is the
+ * responsibility of the {@link TrackController}.
+ *
+ * A break is considered active while `startTime <= currentTime < endTime`,
+ * where `endTime` is `startTime + duration`. Breaks whose duration is unknown
+ * (null) or breaks which restrict `jump` will become active at
+ * `currentTime > startTime`
+ *
+ * This class contains no HLS- or DASH-specific logic; discovery code maps its
+ * protocol's signals to {@link AdBreakInfo} exposed by an
+ * {@link AdsProvider.getAds}, which this controller reads once the provider is
+ * set via {@link AdController.setAdsProvider} (and re-reads on `adsChange`).
+ */
+export declare class AdControllerImpl extends EventHostImpl<AdEventMap> implements AdController {
+    private readonly deps;
+    get [Symbol.toStringTag](): string;
+    private readonly options;
+    private _trackAds;
+    private adsProviderSub;
+    private adsProvider;
+    private midrollAds;
+    private preloadableBreaks;
+    private readonly preloadedBreakIds;
+    private lastPlaybackTime;
+    private pendingAdBreaks;
+    private readonly completeAdBreakIds;
+    private readonly spentBreakIds;
+    private readonly disposer;
+    private adBreakState;
+    private loadingNext;
+    constructor(deps: AdControllerImplDeps, options?: Partial<AdControllerImplOptions>);
+    clearCompletedAds(): void;
+    private isBreakSuppressed;
+    /** The media-time the current ad has actually played, or 0 if not playing. */
+    private adElapsed;
+    /**
+     * Computes whether the current ad may be skipped and, when not yet, how many
+     * seconds remain until it can. A `skip` restriction blocks it outright;
+     * otherwise a resolved skip window gates it by the elapsed break playout, and
+     * with no window the ad is freely skippable.
+     */
+    private resolveSkipState;
+    get currentTrackAds(): (TrackAds | null);
+    private setTrackAds;
+    /**
+     * Returns a function that returns true if the ads provider has changed
+     * since the callback was created.
+     */
+    private providerInterrupted;
+    setAdsProvider(provider: AdsProvider | null): void;
+    enterPreroll(): Promise<AdBreakInfo | null>;
+    enterPostroll(): Promise<AdBreakInfo | null>;
+    private enterRoll;
+    private get hasProvider();
+    skipAdBreak(): void;
+    /**
+     * Marks an ad break as completed (or 'spent' and replayable), emits an `adBreakCompleted` event.
+     */
+    private completeAdBreak;
+    get currentAdBreak(): (AdBreakInfo | null);
+    /**
+     * Marks an ad as completed and emits an `adCompleted` event.
+     */
+    private completeAd;
+    /**
+     * Polls the next pending ad and activates it.
+     * When there are no remaining ads, activates the next ad break (if any).
+     */
+    private nextAdOrBreak;
+    get currentAd(): (AdInfo | null);
+    private get adState();
+    private startAd;
+    /**
+     * Checks if the playhead has entered a time to activate a midroll ad.
+     */
+    private onTimeUpdate;
+    /**
+     * Emits `adPreload` once for each midroll/postroll break the playhead is
+     * approaching — within (the break's {@link AdBreakInfo.resolutionTimeOffset}
+     * or, when absent, the `preloadAheadTime` option) seconds before its start —
+     * so a consumer can resolve and warm the break's assets before entry.
+     * Suppressed (played-once/spent) breaks are skipped.
+     */
+    private checkAdPreload;
+    /**
+     * Main content with ad breaks is playing, check if we have entered a midroll region.
+     */
+    private checkMidrollIngress;
+    /**
+     * Emits events for `adTimeUpdate`, `adFirstQuartile`, `adMidpoint`, and
+     * `adThirdQuartile`.
+     * (Does not emit `adCompleted`)
+     */
+    private emitAdProgressEvents;
+    private emitTimeUpdate;
+    /**
+     * Ads breaks can have a playout limit that may cut off ad playback.
+     * End the ad if that limit is reached.
+     */
+    private enforcePlayoutLimits;
+    private setPendingBreaks;
+    skipAd(): void;
+    failAd(error: Error): void;
+    private endAd;
+    get disposed(): boolean;
+    /**
+     * Disposes this controller, removes all listeners.
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=AdControllerImpl.d.ts.map

package/dist/types/ts3.7/ad/AdError.d.ts

@@ -0,0 +1,6 @@
+import { ErrorLevel, ReportableError } from '@amazon/vinyl-util';
+export declare class AdError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message: string, origin?: string, level?: ErrorLevel);
+}
+//# sourceMappingURL=AdError.d.ts.map

package/dist/types/ts3.7/ad/AdsProvider.d.ts

@@ -0,0 +1,28 @@
+import { AnyRecord, ReadonlyEventHost } from '@amazon/vinyl-util';
+import { TrackAds } from './AdBreakInfo';
+/**
+ * Events dispatched by an {@link AdsProvider}.
+ */
+export interface AdsProviderEventMap {
+    /**
+     * The set of ads has changed; consumers should re-read via
+     * {@link AdsProvider.getAds}.
+     */
+    readonly adsChange: AnyRecord;
+}
+/**
+ * The minimal surface an {@link AdController} needs to source its ad breaks:
+ * a resolver for the current break list, plus an `adsChange` event to signal
+ * when that list changes. A {@link ReadonlyTrack} satisfies this directly, so
+ * the current playing track can be passed as-is; applications may also
+ * implement it to supply ads out of band (e.g. from an external ad server).
+ */
+export interface AdsProvider extends ReadonlyEventHost<AdsProviderEventMap> {
+    /**
+     * Resolves to the provider's current ad breaks. The result may change over
+     * the provider's lifetime; each `adsChange` event indicates that a
+     * subsequent call may return different breaks.
+     */
+    getAds(): Promise<TrackAds>;
+}
+//# sourceMappingURL=AdsProvider.d.ts.map

package/dist/types/ts3.7/ad/defaultAdLoadOptionsResolver.d.ts

@@ -0,0 +1,12 @@
+import { AdInfo } from './AdBreakInfo';
+import { VinylTrackLoadOptions } from '../track/createVinylTrackFactories';
+import { ReportableError } from '@amazon/vinyl-util';
+export declare function defaultAdLoadOptionsResolver(adInfo: AdInfo): Promise<VinylTrackLoadOptions>;
+/**
+ * An error indicating that a method was called with illegal arguments.
+ */
+export declare class UnresolvableAdError extends ReportableError {
+    get [Symbol.toStringTag](): string;
+    constructor(message: string);
+}
+//# sourceMappingURL=defaultAdLoadOptionsResolver.d.ts.map

package/dist/types/ts3.7/ad/discoverHlsInterstitials.d.ts

@@ -0,0 +1,22 @@
+import { HlsMediaPlaylist } from '@amazon/vinyl-hls-parser';
+import { AdBreakList } from './AdBreakInfo';
+/**
+ * Discovers HLS Interstitial ad breaks from a parsed media playlist and maps
+ * them to the provider-agnostic {@link AdBreakInfo} model.
+ *
+ * HLS Interstitials (Apple's SGAI primitive) are carried as EXT-X-DATERANGE
+ * tags with `CLASS="com.apple.hls.interstitial"`. Each such range is anchored
+ * to a wall-clock `START-DATE`; this function converts that to a media-timeline
+ * start time by correlating it with the playlist's EXT-X-PROGRAM-DATE-TIME
+ * anchor. When the playlist carries no program date-time, and the range's
+ * start-date is not otherwise resolvable, the break is anchored to the start of
+ * the timeline (pre-roll) as a best effort.
+ *
+ * @param playlist The parsed HLS media playlist.
+ * @param baseUrl  The URL of the media playlist, used to resolve relative
+ *   `X-ASSET-URI` values.
+ * @param contentDuration The total content duration in seconds, if known, used
+ *   to classify post-rolls. Pass null/undefined for live or unknown durations.
+ */
+export declare function discoverHlsInterstitials(playlist: HlsMediaPlaylist, baseUrl: string, contentDuration?: number | null): Promise<AdBreakList>;
+//# sourceMappingURL=discoverHlsInterstitials.d.ts.map

package/dist/types/ts3.7/drm/DrmController.d.ts

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

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

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

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

@@ -1,5 +1,5 @@
 import { 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/ts3.7/drm/DrmOptions.d.ts

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

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

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

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

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

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

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

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

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

package/dist/types/ts3.7/drm/commonEme/WebKitCommonEme.d.ts

@@ -2,8 +2,8 @@ import { Unsubscribe } from '@amazon/vinyl-util';
 import { Disposable, EventHostImpl } from '@amazon/vinyl-util';
 import { CommonEme, CommonMediaEncryptedEvent, CommonMediaKeys, CommonMediaKeySession, CommonMediaKeySessionEventMap, CommonMediaKeySystemAccess } from './CommonEme';
 import { MediaKeySessionErrorType } from './CommonEme';
-import { DrmKeySystem } from '../../drm/DrmKeySystem';
-import { EncryptedInitData } from '../../drm/commonEme/EncryptedInitData';
+import { DrmKeySystem } from '../DrmKeySystem';
+import { EncryptedInitData } from './EncryptedInitData';
 import { DrmInitDataType } from '../../streaming/DrmInitDataType';
 declare global {
     interface HTMLMediaElementEventMap extends HTMLElementEventMap {

package/dist/types/ts3.7/drm/licenseProvider/LicenseProvider.d.ts

@@ -1,5 +1,5 @@
 import { Maybe, ReadonlyAbort } from '@amazon/vinyl-util';
-import { DrmKeySystem } from '../../drm/DrmKeySystem';
+import { DrmKeySystem } from '../DrmKeySystem';
 import { ObjectSchema } from '@amazon/vinyl-validation';
 /**
  * LicenseProvider handles requesting DRM licenses for specific key systems.

package/dist/types/ts3.7/global/environment.d.ts

@@ -1,6 +1,10 @@
+declare global {
+    var __VINYL_VERSION__: string | undefined;
+}
 /**
- * process.env.VINYL_VERSION will be null in node unit tests, but in the built library it is
- * replaced by the webpack DefinePlugin with the package.version.
+ * `globalThis.__VINYL_VERSION__` is replaced at build time with the package.version via
+ * esbuild's `define` option. In unit tests and unbundled dev builds the replacement does not
+ * happen and the global is undefined, so we fall through to a placeholder version.
  */
 export declare const vinylVersion: import("@amazon/vinyl-util").Version;
 //# sourceMappingURL=environment.d.ts.map

package/dist/types/ts3.7/patch/media/patches/createPreventStallsPatch.d.ts

@@ -1,4 +1,4 @@
-import { HtmlMediaElementPatch } from '../../../patch/media/HtmlMediaElementPatch';
+import { HtmlMediaElementPatch } from '../HtmlMediaElementPatch';
 /**
  * The number of timeupdate events stuck at the same position before attempting to jiggle the playhead.
  * @private

package/dist/types/ts3.7/patch/media/patches/createUnreliablePlaybackEventsPatch.d.ts

@@ -1,4 +1,4 @@
-import { HtmlMediaElementPatch } from '../../../patch/media/HtmlMediaElementPatch';
+import { HtmlMediaElementPatch } from '../HtmlMediaElementPatch';
 /**
  * The interval (in seconds) to poll for time progress in a media element.
  *

package/dist/types/ts3.7/playback/PlaybackControllerImpl.d.ts

@@ -1,7 +1,7 @@
 import { EventHostImpl, ReadonlyRanges } from '@amazon/vinyl-util';
 import { PlaybackController } from './PlaybackController';
 import { PlaybackControllerEventMap, PlaybackReadyState } from './ReadonlyPlaybackController';
-import { LoudnessNormalizationController } from '../playback/loudness/LoudnessNormalizationController';
+import { LoudnessNormalizationController } from './loudness/LoudnessNormalizationController';
 export interface PlaybackControllerImplOptions {
     /**
      * An affordance when comparing the last currentTime and the new currentTime after a seek.
@@ -41,7 +41,7 @@ export declare const defaultPlaybackControllerImplOptions: {
  * Firefox can but if the playhead reaches the end of track before the media stream is closed, an 'ended' event
  * will never fire.
  */
-export declare function getMinSeekableBufferDefault(): 2 | 5;
+export declare function getMinSeekableBufferDefault(): 5 | 2;
 export interface PlaybackControllerImplDeps {
     readonly media: HTMLMediaElement;
     readonly loudnessNormalizationController: LoudnessNormalizationController;

package/dist/types/ts3.7/playback/logging/playbackStateLoggingHandler.d.ts

@@ -1,5 +1,5 @@
 import { Disposable } from '@amazon/vinyl-util';
-import { ReadonlyPlaybackController } from '../../playback/ReadonlyPlaybackController';
+import { ReadonlyPlaybackController } from '../ReadonlyPlaybackController';
 /**
  * The number of seconds to throttle timeupdate logs.
  * Logs will not be emitted for timeupdate events less than this interval.

package/dist/types/ts3.7/playback/nextHasMetadata.d.ts

@@ -1,4 +1,4 @@
-import { PlaybackControllerEventMap, ReadonlyPlaybackController } from '../playback/ReadonlyPlaybackController';
+import { PlaybackControllerEventMap, ReadonlyPlaybackController } from './ReadonlyPlaybackController';
 import { AnyRecord, NextEventAsPromiseOptions } from '@amazon/vinyl-util';
 export declare function nextHasMetadata(controller: ReadonlyPlaybackController, options?: NextEventAsPromiseOptions<PlaybackControllerEventMap, 'loadedMetadata'>): Promise<AnyRecord>;
 //# sourceMappingURL=nextHasMetadata.d.ts.map