@amazon/vinyl 1.2.0 → 2.0.0

package/dist/types/current/track/TrackController.js

@@ -2,16 +2,16 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { countElements, createDisposer, EventHostImpl, first, getOrSet, logDebug, logInfo, LruCache, noop, } from '@amazon/vinyl-util';
+import { countElements, createDisposer, EventHostImpl, first, getOrSet, IllegalStateError, logDebug, logError, logInfo, logVerbose, logWarn, LruCache, noop, resolveValueProvider, } from '@amazon/vinyl-util';
 export const ALL_TRACK_CONTROLLER_EVENTS = [
-    'currentTrackChanging',
-    'currentTrackChange',
+    'trackActivated',
+    'trackDeactivated',
     'queueChange',
+    'trackEnded',
     'queueEnded',
 ];
 const defaultTrackControllerImplOptions = {
     trackPrefetchCount: 2,
-    loadTimeout: 60,
     preloadCapacity: 2,
 };
 /**
@@ -29,47 +29,184 @@ export class TrackControllerImpl extends EventHostImpl {
     }
     // When tracks are preloaded, the cache capacity may expand automatically to accommodate.
     _autoPreloadCapacity = 0;
+    // The primary content track cache. Bounded by preloadCapacity + prefetch.
     trackCache = new LruCache(0);
+    // A monotonically increasing id for a queue change, to allow for queue changes during events.
+    queueIdx = 0;
     _queue = [];
+    // The current content track data in the queue. This will never represent an ad.
     _current = null;
+    // The current Track, may be a content track or an ad track.
+    _currentTrack = null;
+    // The parent content track. Used as a reference to the track that initiated an ad break.
+    adParent = null;
+    // Current-track subscriptions (e.g. `error` → adController.failAd),
+    // re-bound per setCurrentTrack. Promote to a disposer if more are added.
+    currentTrackSub = null;
+    // Ad tracks keyed by parent content URI, kept out of the content cache.
+    // Pegged to the parent: disposed when the parent is evicted (see onEvict).
+    adTracksByParent = new Map();
     disposer = createDisposer();
     _options = defaultTrackControllerImplOptions;
-    trackEndedTimeoutId = null;
     constructor(deps, initialOptions) {
         super();
         this.deps = deps;
         const { add } = this.disposer;
+        const { playbackController } = deps;
         this.trackCache.onEvicting = (track) => {
             // Do not evict tracks within the prefetch range.
-            return (this.prefetched.find((value) => value.uri === track.uri) == null);
+            return (this.getPrefetched().find((value) => value.uri === track.uri) ==
+                null);
         };
         this.trackCache.onEvict = (track) => {
             logDebug(this, `Disposing track: ${track.uri}`);
+            // Ad tracks are pegged to their parent — disposing them here keeps
+            // them from outliving the content track they belong to.
+            this.disposeAdTracksFor(track.uri);
             track.dispose();
             return true;
         };
-        add(deps.playbackController.on('ended', () => {
-            this.trackEndedTimeoutId = setTimeout(() => {
-                // Adds a frame delay to allow applications an opportunity to respond to 'ended' events before the
-                // track is changed.
-                this.trackEndedTimeoutId = null;
-                if (this.hasNext()) {
-                    this.next();
+        add(playbackController.on('ended', this.onEnded));
+        this.initializeAdHandling();
+        this.configure(initialOptions);
+    }
+    initializeAdHandling() {
+        const { add } = this.disposer;
+        const { adController, adTrackLoadOptionsProvider, playbackController } = this.deps;
+        add(adController.on('adPreload', (event) => {
+            // The playhead is approaching a midroll/postroll break; warm its
+            // ad tracks for the current content track so they are ready on
+            // entry. Prerolls are already warmed by preloadPrerollAds.
+            const adParent = this.adParent;
+            if (adParent)
+                this.preloadBreakAds(adParent, event.adBreak);
+        }));
+        add(adController.on('adEntered', (event) => {
+            const adParent = this.adParent;
+            if (!adParent) {
+                logDebug(this, 'ad entered, no parent track');
+                return;
+            }
+            const interrupted = () => this.adParent !== adParent ||
+                adController.currentAd !== event.ad;
+            if (event.ad.uri) {
+                // Infer the track load options from the ad.
+                adTrackLoadOptionsProvider(event.ad)
+                    .then((adTrack) => {
+                    if (!interrupted()) {
+                        // set adTrack
+                        this.setCurrentTrack(this.getOrCreateAdTrack(adParent.uri, adTrack), {
+                            isAd: true,
+                            checkPreroll: false,
+                            config: {},
+                        });
+                        playbackController.play().catch(noop);
+                    }
+                })
+                    .catch((error) => {
+                    if (!interrupted())
+                        adController.failAd(error);
+                });
+            }
+        }));
+        add(adController.on('adBreakCompleted', (event) => {
+            logDebug(this, 'adBreakCompleted');
+            const adParent = this.adParent;
+            if (!adParent) {
+                logDebug(this, 'ad break completed, no parent track');
+                return;
+            }
+            if (adController.currentAdBreak) {
+                logDebug(this, 'more adbreaks');
+                return;
+            }
+            if (adParent.active) {
+                logDebug(this, 'no ads began');
+                return;
+            }
+            const adParentLoad = this._current;
+            const placement = event.adBreak.placement;
+            const isPreroll = placement === 'preroll';
+            const isPostroll = placement === 'postroll';
+            // A completed postroll marks the end of the whole track
+            // (content + postroll); preroll/midroll only resume content.
+            if (isPostroll) {
+                logDebug(this, 'trackEnded after postroll');
+                this.dispatch('trackEnded', { track: adParentLoad });
+            }
+            if (isPostroll && this.hasNext()) {
+                this.next();
+            }
+            else {
+                // Overrides the config startTime to resume from the correct position.
+                const startTime = isPreroll
+                    ? adParentLoad.config?.startTime
+                    : event.resumePosition;
+                // Resume the main track.
+                this.setCurrentTrack(adParent, {
+                    config: {
+                        ...adParentLoad.config,
+                        startTime,
+                    },
+                    isAd: false,
+                    checkPreroll: false,
+                });
+                if (isPostroll) {
+                    logInfo(this, 'queueEnded after postroll ad(s)');
+                    this.dispatch('queueEnded', {});
                 }
                 else {
-                    logInfo(this, 'queueEnded');
-                    this.dispatch('queueEnded', {});
+                    playbackController.play().catch(noop);
                 }
-            });
+            }
         }));
-        this.configure(initialOptions);
     }
-    clearTrackEndedTimeout() {
-        if (this.trackEndedTimeoutId) {
-            clearTimeout(this.trackEndedTimeoutId);
-            this.trackEndedTimeoutId = null;
+    /**
+     * The current track has ended naturally. On the next tick advance the queue or emit queue ended.
+     */
+    onEnded = () => {
+        const { adController } = this.deps;
+        // `ended` fires for ad tracks too (they share the media element); an
+        // ad's end is the AdController's concern, the queue or content may be resumed on 'adBreakCompleted'
+        if (this.currentTrackIsAdTrack)
+            return;
+        const track = this._current;
+        if (!track) {
+            logWarn(this, 'an ended event was received with no current track');
+            return;
         }
-    }
+        const interrupted = this.getQueueInterrupted();
+        adController
+            .enterPostroll()
+            .then((postroll) => {
+            if (postroll) {
+                // There is a pending postroll, do not advance the queue,
+                // a new adEntered event will fire.
+                logDebug(this, 'postroll entered');
+            }
+            else {
+                // The content ended with no postroll: the track is done.
+                logDebug(this, 'trackEnded');
+                this.dispatch('trackEnded', { track });
+                // Adds a microtask delay to allow applications an opportunity to respond to 'ended' and 'trackEnded'
+                // events before the queue is advanced.
+                queueMicrotask(() => {
+                    if (interrupted())
+                        return;
+                    if (this.hasNext()) {
+                        this.next();
+                    }
+                    else {
+                        logInfo(this, 'queueEnded');
+                        this.dispatch('queueEnded', {});
+                    }
+                });
+            }
+        })
+            .catch((error) => {
+            logError(this, 'enterPostroll failed', error);
+        });
+    };
     /**
      * Returns the currently set configuration.
      */
@@ -106,7 +243,7 @@ export class TrackControllerImpl extends EventHostImpl {
      * Returns the subset of the queue that should be prefetched.
      * @private
      */
-    get prefetched() {
+    getPrefetched() {
         const tracks = [];
         if (this._current)
             tracks.push(this._current);
@@ -136,7 +273,7 @@ export class TrackControllerImpl extends EventHostImpl {
         this._preload(loadOptionsList);
     }
     _preload(loadOptionsList) {
-        const prefetched = this.prefetched;
+        const prefetched = this.getPrefetched();
         // Calculate the required preload capacity as the number of tracks requested that are not within the
         // prefetch window. If this value is greater than the current preloadCapacity, increase the cache size.
         const requiredPreloadCapacity = countElements(loadOptionsList, (loadOptions) => {
@@ -153,25 +290,77 @@ export class TrackControllerImpl extends EventHostImpl {
         trackPriority.value += loadOptionsList.length;
         let priority = trackPriority.value;
         for (const loadOptions of loadOptionsList) {
-            const track = this.getOrCreateTrack(loadOptions.uri, loadOptions);
+            const track = this.getOrCreateTrack(loadOptions);
+            const prefetchPriority = priority--;
+            logVerbose(this, `preloading track ${track.uri} with priority ${prefetchPriority}`);
             track.preload({
-                prefetchPriority: priority--,
+                prefetchPriority,
             }, loadOptions.config ?? {});
+            this.preloadPrerollAds(track, prefetchPriority);
         }
     }
+    preloadPrerollAds(parentTrack, parentTrackPriority) {
+        parentTrack
+            .getAds()
+            .then(async (trackAds) => {
+            for (const [index, adBreak] of trackAds.adBreaks.entries()) {
+                if (adBreak.placement !== 'preroll')
+                    continue;
+                const ads = await resolveValueProvider(adBreak.ads);
+                for (const ad of ads) {
+                    await this.preloadAd({
+                        parentTrack,
+                        // A prefetch priority fractionally higher than the
+                        // parent track (so a preroll is warmed before its
+                        // content), later breaks slightly higher than earlier.
+                        prefetchPriority: parentTrackPriority + (index + 1) / 1000,
+                        ad,
+                    });
+                }
+            }
+        })
+            .catch((error) => {
+            // Preloading prerolls is best-effort: an ad-discovery, ad-list,
+            // or ad-options failure must not surface as an unhandled
+            // rejection (it just means the preroll isn't warmed up).
+            logVerbose(this, `preroll ad preload failed for ${parentTrack.uri}`, error);
+        });
+    }
+    /**
+     * Warms the ad tracks for an approaching midroll/postroll break (driven by
+     * the ad controller's `adPreload`). Best-effort: an ad-list or ad-options
+     * failure is logged, not thrown. The break is imminent, so its ad tracks
+     * get a prefetch priority above the current content prefetch window.
+     */
+    preloadBreakAds(parentTrack, adBreak) {
+        trackPriority.value += 1;
+        const prefetchPriority = trackPriority.value;
+        resolveValueProvider(adBreak.ads)
+            .then(async (ads) => {
+            for (const ad of ads) {
+                await this.preloadAd({ parentTrack, prefetchPriority, ad });
+            }
+        })
+            .catch((error) => {
+            logVerbose(this, `ad preload failed for break ${adBreak.id}`, error);
+        });
+    }
+    /** Preloads an ad for a parent track. Aborts if the parent track is disposed before the ad load options resolve. **/
+    async preloadAd({ parentTrack, prefetchPriority, ad, }) {
+        const { adTrackLoadOptionsProvider } = this.deps;
+        const loadOptions = await adTrackLoadOptionsProvider(ad);
+        if (parentTrack.disposed)
+            return;
+        logVerbose(this, `preloading ad id=${ad.id} uri=${ad.uri} priority=${prefetchPriority}`);
+        const adTrack = this.getOrCreateAdTrack(parentTrack.uri, loadOptions);
+        adTrack.preload({
+            prefetchPriority,
+        }, loadOptions.config ?? {});
+    }
     load(...loadOptionsList) {
         logDebug(this, `load ${loadOptionsList.length} items`);
         loadOptionsList.forEach(this.validateLoadOptions);
-        this.clearTrackEndedTimeout();
-        this._current = loadOptionsList[0] ?? null;
-        const previousQueue = this._queue;
-        this._queue = loadOptionsList.slice(1);
-        this._preload(this.prefetched);
-        this.activateCurrent();
-        this.dispatch('queueChange', {
-            previous: previousQueue,
-            current: this._queue,
-        });
+        this.setQueue(loadOptionsList[0], loadOptionsList.slice(1));
     }
     unload() {
         this.load();
@@ -179,56 +368,30 @@ export class TrackControllerImpl extends EventHostImpl {
     enqueue(...loadOptionsList) {
         logDebug(this, `enqueue ${loadOptionsList.length} items`);
         loadOptionsList.forEach(this.validateLoadOptions);
-        const previousQueue = this._queue;
-        this._queue = this._queue.concat(loadOptionsList);
-        this._preload(this.prefetched);
-        if (this.currentTrack == null && this.hasNext())
+        this.setQueue(this._current, this._queue.concat(loadOptionsList));
+        if (this._currentTrack == null && this.hasNext())
             this.next();
-        this.dispatch('queueChange', {
-            previous: previousQueue,
-            current: this._queue,
-        });
     }
     hasNext() {
         return this._queue.length > 0;
     }
     next() {
-        this.clearTrackEndedTimeout();
         const playbackController = this.deps.playbackController;
         const shouldPlay = playbackController.ended || !playbackController.paused;
         const next = first(this._queue);
-        const previousQueue = this._queue;
-        this._queue = this._queue.slice(1);
-        this._current = next ?? null;
-        logDebug(this, 'next, nextTrack:', this._current);
-        if (this.options.trackPrefetchCount > 0 &&
-            this._queue.length >= this.options.trackPrefetchCount) {
-            this._preload([this._queue[this.options.trackPrefetchCount - 1]]);
-        }
-        this.activateCurrent();
-        if (shouldPlay)
-            void playbackController.play().catch(noop);
-        this.dispatch('queueChange', {
-            previous: previousQueue,
-            current: this._queue,
-        });
+        logDebug(this, 'next, nextTrack:', next);
+        this.setQueue(next, this._queue.slice(1), { shouldPlay });
     }
     clearTrackCache() {
         logDebug(this, 'clearTrackCache');
-        this.clearTrackEndedTimeout();
-        const previousQueue = this._queue;
-        this._queue = [];
         this.trackCache.forEach((track) => {
+            this.disposeAdTracksFor(track.uri);
             track.dispose();
         });
         this.trackCache.clear();
         this._autoPreloadCapacity = 0;
         this.checkCacheCapacity();
-        this.clearCurrentTrack();
-        this.dispatch('queueChange', {
-            previous: previousQueue,
-            current: this._queue,
-        });
+        this.setQueue(null, []);
     }
     clearPrefetch() {
         for (const cachedTrack of this.trackCache.values()) {
@@ -236,72 +399,162 @@ export class TrackControllerImpl extends EventHostImpl {
         }
     }
     clearQueue() {
-        this.clearTrackEndedTimeout();
-        const previous = this._queue;
-        this._queue = [];
-        this.dispatch('queueChange', {
-            previous,
-            current: this._queue,
-        });
+        // Clears the upcoming queue without unloading the current track.
+        this.setQueue(this._current, []);
     }
     /**
      * If the given track id is the current track or in the cache, returns that track.
      * Otherwise, constructs a new track, adds it to the cache, and returns it.
      *
-     * @param uri The unique resource identifier.
      * @param loadOptions
      * @private
      */
-    getOrCreateTrack(uri, loadOptions) {
-        return getOrSet(this.trackCache, uri, () => {
-            const newTrack = this.deps.trackFactory.createTrack(loadOptions);
-            this.trackCache.set(uri, newTrack);
-            return newTrack;
-        });
+    getOrCreateTrack(loadOptions) {
+        return getOrSet(this.trackCache, loadOptions.uri, () => this.deps.trackFactory.createTrack(loadOptions));
     }
     /**
-     * Get the current track from cache or create a new track, then activates that track.
+     * Gets the cached ad track, or creates a new one and sets it in the
+     * parent track mapping.
+     * When the parent track is disposed, this ad track will be as well.
+     *
+     * @param parentUri The URI of the parent track.
+     * @param loadOptions
+     * @private
      */
-    activateCurrent() {
-        const loadOptions = this._current;
-        if (!loadOptions) {
-            this.clearCurrentTrack();
-            return;
+    getOrCreateAdTrack(parentUri, loadOptions) {
+        const parentTracks = getOrSet(this.adTracksByParent, parentUri, () => new Map());
+        return getOrSet(parentTracks, loadOptions.uri, () => this.deps.trackFactory.createTrack(loadOptions));
+    }
+    /**
+     * Sets the current track and following queue.
+     *
+     * If the given track is already current, it will be de-activated and re-activated and the
+     * trackDeactivated/trackActivated events will still be emitted. The same track may be in the
+     * queue multiple times.
+     */
+    setQueue(current, queue, options) {
+        const { playbackController } = this.deps;
+        ++this.queueIdx;
+        const interrupted = this.getQueueInterrupted();
+        const previousQueue = this._queue;
+        const previous = this._current;
+        if (previous !== current) {
+            // Update the pointers before materializing the track, so eviction
+            // protects the incoming track and its window, not the outgoing one.
+            this._current = current ?? null;
+            this._queue = queue;
+            this.setCurrentTrack(current ? this.getOrCreateTrack(current) : null, {
+                isAd: false,
+                checkPreroll: true,
+                config: current?.config,
+            });
+            if (options?.shouldPlay) {
+                // playback controller defers play until the new track is loaded
+                playbackController.play().catch(noop);
+            }
+        }
+        else {
+            // Current track unchanged but the queue may have (e.g. enqueue).
+            // Keep it in sync so hasNext()/next() work.
+            this._queue = queue;
+        }
+        this._preload(this.getPrefetched());
+        logDebug(this, `track change, previous: ${previous?.uri} current: ${current?.uri}`);
+        if (previousQueue !== queue) {
+            this.dispatch('queueChange', {
+                previous: previousQueue,
+                current: queue,
+            });
+        }
+        if (interrupted()) {
+            throw new IllegalStateError(`cannot change the queue on a 'queueChange' or 'trackDeactivated' event`);
         }
-        this.setCurrentTrack(this.getOrCreateTrack(loadOptions.uri, loadOptions), loadOptions);
     }
-    _currentTrack = null;
-    get currentTrack() {
-        return this._currentTrack;
+    get currentTrackIsAdTrack() {
+        return this._currentTrack !== this.adParent;
     }
     /**
-     * Sets the current track. If the given track is already current, it will be de-activated and re-activated and
-     * the currentTrackChange event will still be emitted.
-     * The same track may be in the queue multiple times.
+     * Sets the active track.
+     * This may either be a content track created from `setQueue` or an ad track created from `adEntered`.
+     *
+     * @param newTrack
+     * @param options
+     * @private
      */
-    setCurrentTrack(value, loadOptions) {
+    setCurrentTrack(newTrack, options) {
+        const { adController } = this.deps;
         const previousTrack = this._currentTrack;
-        this.dispatch('currentTrackChanging', {
-            previous: previousTrack,
-            current: value,
-        });
-        this._currentTrack = value;
-        if (previousTrack?.active === true)
-            previousTrack.deactivate();
-        const loadOptionsConfig = loadOptions?.config ?? {};
-        if (value?.active === false)
-            value.activate(loadOptionsConfig);
-        logDebug(this, `currentTrackChange, previous: ${previousTrack} current: ${value}`);
-        this.dispatch('currentTrackChange', {
-            previous: previousTrack,
-            current: value,
-        });
+        const previousWasActive = previousTrack?.active ?? false;
+        this._currentTrack = newTrack;
+        const interrupted = () => this._currentTrack !== newTrack;
+        previousTrack?.deactivate();
+        if (previousTrack && previousWasActive) {
+            this.dispatch('trackDeactivated', { track: previousTrack });
+        }
+        // Forward the active track's errors to the ad controller. When an ad
+        // track errors (fails to load or errors mid-playback), this fails the
+        // ad so the break advances rather than stalling on the broken ad; on a
+        // content track failAd is a no-op (the error still surfaces as a player
+        // error). Re-subscribed per track and torn down on the next change.
+        this.currentTrackSub?.();
+        this.currentTrackSub =
+            newTrack?.on('error', (event) => adController.failAd(event.error)) ?? null;
+        if (!options.isAd) {
+            this.adParent = newTrack;
+            adController.setAdsProvider(newTrack);
+        }
+        if (newTrack) {
+            const activate = () => {
+                if (interrupted())
+                    return;
+                newTrack.activate(options.config ?? {});
+                this.dispatch('trackActivated', { track: newTrack });
+            };
+            if (options.isAd || !options.checkPreroll) {
+                activate(); // Ads cannot have prerolls.
+            }
+            else {
+                adController
+                    .enterPreroll()
+                    .then((preroll) => {
+                    if (preroll)
+                        return; // preroll entered
+                    activate();
+                })
+                    .catch((error) => {
+                    logError(this, 'enterPreroll failed', error);
+                    activate();
+                });
+            }
+        }
+    }
+    /**
+     * Disposes all preloaded ad tracks belonging to the given parent content
+     * URI and drops the parent's entry from the ad map.
+     */
+    disposeAdTracksFor(parentUri) {
+        const adTracks = this.adTracksByParent.get(parentUri);
+        if (!adTracks)
+            return;
+        this.adTracksByParent.delete(parentUri);
+        for (const track of adTracks.values())
+            track.dispose();
+    }
+    /**
+     * Returns a callback that returns true if the queue has changed or the controller disposed.
+     */
+    getQueueInterrupted() {
+        const idx = this.queueIdx;
+        return () => this.disposed || this.queueIdx !== idx;
+    }
+    get activeTrack() {
+        return this._currentTrack?.active ? this._currentTrack : null;
     }
-    clearCurrentTrack() {
-        this.setCurrentTrack(null, null);
+    reset(hard = false) {
+        this._currentTrack?.reset(hard);
     }
-    reset() {
-        this._currentTrack?.reset();
+    get disposed() {
+        return this.disposer.disposed;
     }
     dispose() {
         logDebug(this, 'dispose');

package/dist/types/current/track/TrackFactory.d.ts

@@ -1,6 +1,7 @@
-import type { AnyRecord, Maybe, ReadonlyRecord } from '@amazon/vinyl-util';
-import type { ObjectSchema } from '@amazon/vinyl-validation';
+import { type Maybe, type ReadonlyRecord } from '@amazon/vinyl-util';
+import { type ObjectSchema } from '@amazon/vinyl-validation';
 import type { Track, TrackTypeId, TrackUri } from './Track';
+import { type DrmOptions } from '../drm/DrmOptions';
 export interface TrackLoadOptions {
     /**
      * The track type, used to map to a track factory.
@@ -13,8 +14,27 @@ export interface TrackLoadOptions {
     /**
      * The track configuration.
      */
-    readonly config?: Maybe<AnyRecord>;
+    readonly config?: Maybe<TrackConfigOptions>;
 }
+/**
+ * General configuration for tracks set in track load options.
+ */
+export interface TrackConfigOptions {
+    /**
+     * The time to seek to when the track has been activated.
+     * For MSE tracks this will affect pre-fetching.
+     */
+    readonly startTime?: Maybe<number>;
+    /**
+     * Extra application data to associate with the track.
+     */
+    readonly extra?: any;
+    /**
+     * DRM Configuration overrides for this track.
+     */
+    readonly drm?: Partial<DrmOptions>;
+}
+export declare const trackConfigOptionsValidator: ObjectSchema<TrackConfigOptions>;
 export declare const trackLoadOptionsValidator: ObjectSchema<TrackLoadOptions>;
 /**
  * Produces a new Track for the given configuration options.

package/dist/types/current/track/TrackFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TrackFactory.d.ts","sourceRoot":"","sources":["../../../../src/track/TrackFactory.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAE1E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAA;AAQ5D,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAE3D,MAAM,WAAW,gBAAgB;IAC7B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAE1B;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAA;IAEtB;;OAEG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC,CAAA;CACrC;AAED,eAAO,MAAM,yBAAyB,EAAE,YAAY,CAAC,gBAAgB,CAMpE,CAAA;AAED;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,oBAAoB,SAAS,gBAAgB;IACvE;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CAAA;IAE7C;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,oBAAoB,GAAG,KAAK,CAAA;CACpD;AAED,MAAM,MAAM,2BAA2B,CAAC,CAAC,SAAS,YAAY,CAAC,GAAG,CAAC,IAC/D,CAAC,SAAS,YAAY,CAAC,MAAM,WAAW,CAAC,GAAG,WAAW,GAAG,KAAK,CAAA;AAEnE,MAAM,MAAM,2BAA2B,CACnC,CAAC,SAAS,cAAc,CAAC,WAAW,EAAE,YAAY,CAAC,gBAAgB,CAAC,CAAC,IACrE,2BAA2B,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;AAE3C,MAAM,MAAM,kBAAkB,GAAG,cAAc,CAC3C,WAAW,EACX,YAAY,CAAC,gBAAgB,CAAC,CACjC,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,kBAAkB,IAAI;IAChE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,SAAS,2BAA2B,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GACtE,CAAC,CAAC,CAAC,CAAC,GACJ,KAAK;CACd,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,kBAAkB,EAC3D,SAAS,EAAE,uBAAuB,CAAC,CAAC,CAAC,GACtC,YAAY,CAAC,2BAA2B,CAAC,CAAC,CAAC,CAAC,CAa9C"}
+{"version":3,"file":"TrackFactory.d.ts","sourceRoot":"","sources":["../../../../src/track/TrackFactory.ts"],"names":[],"mappings":"AAKA,OAAO,EAEH,KAAK,KAAK,EAEV,KAAK,cAAc,EACtB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAKH,KAAK,YAAY,EAGpB,MAAM,0BAA0B,CAAA;AAEjC,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAC3D,OAAO,EAAE,KAAK,UAAU,EAAuB,MAAM,mBAAmB,CAAA;AAExE,MAAM,WAAW,gBAAgB;IAC7B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;IAE1B;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAA;IAEtB;;OAEG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAA;CAC9C;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAElC;;OAEG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,GAAG,CAAA;IAEpB;;OAEG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAA;CACrC;AAED,eAAO,MAAM,2BAA2B,EAAE,YAAY,CAAC,kBAAkB,CAKnE,CAAA;AAEN,eAAO,MAAM,yBAAyB,EAAE,YAAY,CAAC,gBAAgB,CAMpE,CAAA;AAED;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,oBAAoB,SAAS,gBAAgB;IACvE;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CAAA;IAE7C;;OAEG;IACH,WAAW,CAAC,OAAO,EAAE,oBAAoB,GAAG,KAAK,CAAA;CACpD;AAED,MAAM,MAAM,2BAA2B,CAAC,CAAC,SAAS,YAAY,CAAC,GAAG,CAAC,IAC/D,CAAC,SAAS,YAAY,CAAC,MAAM,WAAW,CAAC,GAAG,WAAW,GAAG,KAAK,CAAA;AAEnE,MAAM,MAAM,2BAA2B,CACnC,CAAC,SAAS,cAAc,CAAC,WAAW,EAAE,YAAY,CAAC,gBAAgB,CAAC,CAAC,IACrE,2BAA2B,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;AAE3C,MAAM,MAAM,kBAAkB,GAAG,cAAc,CAC3C,WAAW,EACX,YAAY,CAAC,gBAAgB,CAAC,CACjC,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,uBAAuB,CAAC,CAAC,SAAS,kBAAkB,IAAI;IAChE,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,SAAS,2BAA2B,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GACtE,CAAC,CAAC,CAAC,CAAC,GACJ,KAAK;CACd,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,kBAAkB,EAC3D,SAAS,EAAE,uBAAuB,CAAC,CAAC,CAAC,GACtC,YAAY,CAAC,2BAA2B,CAAC,CAAC,CAAC,CAAC,CAa9C"}

package/dist/types/current/track/TrackFactory.js

@@ -2,12 +2,18 @@
  * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
-import { ErrorOrigin, ownKeys } from '@amazon/vinyl-util';
-import { isOneOf, object, string, } from '@amazon/vinyl-validation';
+import { ErrorOrigin, ownKeys, } from '@amazon/vinyl-util';
+import { any, isOneOf, number, object, string, } from '@amazon/vinyl-validation';
+import { drmOptionsValidator } from '../drm/DrmOptions';
+export const trackConfigOptionsValidator = object({
+    extra: any().optional(),
+    startTime: number().maybe().optional(),
+    drm: drmOptionsValidator.partial().optional(),
+});
 export const trackLoadOptionsValidator = object({
     type: string(),
     uri: string().notEmpty(),
-    config: object({}).maybe().optional(),
+    config: trackConfigOptionsValidator.maybe().optional(),
 });
 /**
  * Given a map of TrackTypeId => TrackFactory, returns a track factory