eyevinn-channel-engine 3.3.11 → 3.4.0

package/dist/engine/session.js

@@ -0,0 +1,2194 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var crypto = require('crypto');
+var debug = require('debug')('engine-session');
+var HLSVod = require('@eyevinn/hls-vodtolive');
+var m3u8 = require('@eyevinn/m3u8');
+var HLSRepeatVod = require('@eyevinn/hls-repeat');
+var HLSTruncateVod = require('@eyevinn/hls-truncate');
+var Readable = require('stream').Readable;
+var SessionState = require('./session_state.js').SessionState;
+var PlayheadState = require('./playhead_state.js').PlayheadState;
+var _a = require('./util.js'), applyFilter = _a.applyFilter, cloudWatchLog = _a.cloudWatchLog, m3u8Header = _a.m3u8Header, logerror = _a.logerror;
+var ChaosMonkey = require('./chaos_monkey.js');
+var AVERAGE_SEGMENT_DURATION = 3000;
+var DEFAULT_PLAYHEAD_DIFF_THRESHOLD = 1000;
+var DEFAULT_MAX_TICK_INTERVAL = 10000;
+var DEFAULT_DIFF_COMPENSATION_RATE = 0.5;
+var timer = function (ms) { return new Promise(function (res) { return setTimeout(res, ms); }); };
+var Session = /** @class */ (function () {
+    /**
+     *
+     * config: {
+     *   startWithId,
+     * }
+     *
+     */
+    function Session(assetManager, config, sessionStore) {
+        this._assetManager = assetManager;
+        this._sessionId = crypto.randomBytes(20).toString('hex');
+        this._sessionStateStore = sessionStore.sessionStateStore;
+        this._playheadStateStore = sessionStore.playheadStateStore;
+        this._instanceId = sessionStore.instanceId;
+        //this.currentVod;
+        this.currentMetadata = {};
+        this._events = [];
+        this.averageSegmentDuration = AVERAGE_SEGMENT_DURATION;
+        this.use_demuxed_audio = false;
+        this.cloudWatchLogging = false;
+        this.playheadDiffThreshold = DEFAULT_PLAYHEAD_DIFF_THRESHOLD;
+        this.maxTickInterval = DEFAULT_MAX_TICK_INTERVAL;
+        this.maxTickIntervalIsDefault = true;
+        this.diffCompensationRate = DEFAULT_DIFF_COMPENSATION_RATE;
+        this.diffCompensation = null;
+        this.timePositionOffset = 0;
+        this.prevVodMediaSeq = {
+            video: null,
+            audio: null
+        };
+        this.prevMediaSeqOffset = {
+            video: null,
+            audio: null
+        };
+        this.waitingForNextVod = false;
+        this.leaderIsSettingNextVod = false;
+        this.isSwitchingBackToV2L = false;
+        this.switchDataForSession = {
+            mediaSeq: null,
+            discSeq: null,
+            mediaSeqOffset: null,
+            transitionSegments: null,
+            reloadBehind: null,
+        };
+        this.isAllowedToClearVodCache = null;
+        this.alwaysNewSegments = null;
+        if (config) {
+            if (config.alwaysNewSegments) {
+                this.alwaysNewSegments = config.alwaysNewSegments;
+            }
+            if (config.sessionId) {
+                this._sessionId = config.sessionId;
+            }
+            if (config.category) {
+                this._category = config.category;
+            }
+            if (config.averageSegmentDuration) {
+                this.averageSegmentDuration = config.averageSegmentDuration;
+            }
+            if (config.useDemuxedAudio) {
+                this.use_demuxed_audio = true;
+            }
+            if (config.startWithId) {
+                this.startWithId = config.startWithId;
+            }
+            if (config.profile) {
+                this._sessionProfile = config.profile;
+            }
+            if (config.audioTracks) {
+                this._audioTracks = config.audioTracks;
+            }
+            if (config.closedCaptions) {
+                this._closedCaptions = config.closedCaptions;
+            }
+            if (config.slateUri) {
+                this.slateUri = config.slateUri;
+                this.slateRepetitions = config.slateRepetitions || 10;
+                this.slateDuration = config.slateDuration || 4000;
+                debug("Will use slate URI ".concat(this.slateUri, " (").concat(this.slateRepetitions, " ").concat(this.slateDuration, "ms)"));
+            }
+            if (config.cloudWatchMetrics) {
+                this.cloudWatchLogging = true;
+            }
+            if (config.playheadDiffThreshold) {
+                this.playheadDiffThreshold = config.playheadDiffThreshold;
+            }
+            if (config.maxTickInterval) {
+                this.maxTickInterval = config.maxTickInterval;
+                this.maxTickIntervalIsDefault = false;
+            }
+            if (config.disabledPlayhead) {
+                this.disabledPlayhead = true;
+            }
+            if (config.targetDurationPadding) {
+                this.targetDurationPadding = config.targetDurationPadding;
+            }
+            if (config.forceTargetDuration) {
+                this.forceTargetDuration = config.forceTargetDuration;
+            }
+            if (config.diffCompensationRate) {
+                this.diffCompensationRate = config.diffCompensationRate;
+            }
+        }
+    }
+    Session.prototype.initAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _a = this;
+                        return [4 /*yield*/, this._sessionStateStore.create(this._sessionId, this._instanceId)];
+                    case 1:
+                        _a._sessionState = _c.sent();
+                        _b = this;
+                        return [4 /*yield*/, this._playheadStateStore.create(this._sessionId)];
+                    case 2:
+                        _b._playheadState = _c.sent();
+                        if (!this.startWithId) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_INIT_BY_ID)];
+                    case 3:
+                        _c.sent();
+                        return [4 /*yield*/, this._sessionState.set("assetId", this.startWithId)];
+                    case 4:
+                        _c.sent();
+                        _c.label = 5;
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Object.defineProperty(Session.prototype, "sessionId", {
+        get: function () {
+            return this._sessionId;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Session.prototype.startPlayheadAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var playheadState, state, numberOfLargeTicks, tsIncrementBegin, manifest, tsIncrementEnd, sessionState, isLeader, firstDuration, tickInterval, reqTickInterval, timeSpentInIncrement, tickInterval, delta, position, timePosition, diff, timeToAdd, timeToAdd, DIFF_COMPENSATION, changeMaxTick, tsTickEnd, lastDuration, nextTickInterval, err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        debug("[".concat(this._sessionId, "]: Playhead consumer started:"));
+                        debug("[".concat(this._sessionId, "]: diffThreshold=").concat(this.playheadDiffThreshold));
+                        debug("[".concat(this._sessionId, "]: maxTickInterval=").concat(this.maxTickInterval));
+                        debug("[".concat(this._sessionId, "]: averageSegmentDuration=").concat(this.averageSegmentDuration));
+                        this.disabledPlayhead = false;
+                        return [4 /*yield*/, this._playheadState.getValues(["state"])];
+                    case 1:
+                        playheadState = _a.sent();
+                        return [4 /*yield*/, this._playheadState.setState(PlayheadState.RUNNING)];
+                    case 2:
+                        state = _a.sent();
+                        numberOfLargeTicks = 0;
+                        _a.label = 3;
+                    case 3:
+                        if (!(state !== PlayheadState.CRASHED)) return [3 /*break*/, 25];
+                        _a.label = 4;
+                    case 4:
+                        _a.trys.push([4, 22, , 24]);
+                        tsIncrementBegin = Date.now();
+                        return [4 /*yield*/, this.incrementAsync()];
+                    case 5:
+                        manifest = _a.sent();
+                        if (!!manifest) return [3 /*break*/, 7];
+                        debug("[".concat(this._sessionId, "]: No manifest available yet, will try again after 1000ms"));
+                        return [4 /*yield*/, timer(1000)];
+                    case 6:
+                        _a.sent();
+                        return [3 /*break*/, 3];
+                    case 7:
+                        tsIncrementEnd = Date.now();
+                        return [4 /*yield*/, this._sessionState.getValues(["state"])];
+                    case 8:
+                        sessionState = _a.sent();
+                        return [4 /*yield*/, this._playheadState.getValues(["tickInterval", "playheadRef", "tickMs"])];
+                    case 9:
+                        playheadState = _a.sent();
+                        return [4 /*yield*/, this._playheadState.getState()];
+                    case 10:
+                        state = _a.sent();
+                        return [4 /*yield*/, this._sessionStateStore.isLeader(this._instanceId)];
+                    case 11:
+                        isLeader = _a.sent();
+                        if (!(isLeader &&
+                            [
+                                SessionState.VOD_NEXT_INIT,
+                                SessionState.VOD_NEXT_INITIATING,
+                                SessionState.VOD_RELOAD_INIT,
+                                SessionState.VOD_RELOAD_INITIATING
+                            ].indexOf(sessionState.state) !== -1)) return [3 /*break*/, 13];
+                        return [4 /*yield*/, this._getFirstDuration(manifest)];
+                    case 12:
+                        firstDuration = _a.sent();
+                        tickInterval = firstDuration < 2 ? 2 : firstDuration;
+                        debug("[".concat(this._sessionId, "]: I am the leader and updated tick interval to ").concat(tickInterval, " sec"));
+                        cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'tickIntervalUpdated', channel: this._sessionId, tickIntervalSec: tickInterval });
+                        this._playheadState.set("tickInterval", tickInterval);
+                        return [3 /*break*/, 21];
+                    case 13:
+                        if (!(state == PlayheadState.STOPPED)) return [3 /*break*/, 14];
+                        debug("[".concat(this._sessionId, "]: Stopping playhead"));
+                        return [2 /*return*/];
+                    case 14:
+                        reqTickInterval = playheadState.tickInterval;
+                        timeSpentInIncrement = (tsIncrementEnd - tsIncrementBegin) / 1000;
+                        tickInterval = reqTickInterval - timeSpentInIncrement;
+                        return [4 /*yield*/, this._getCurrentDeltaTime()];
+                    case 15:
+                        delta = _a.sent();
+                        if (delta != 0) {
+                            tickInterval += delta;
+                            debug("[".concat(this._sessionId, "]: Delta time is != 0 need will adjust ").concat(delta, "sec to tick interval. tick=").concat(tickInterval));
+                        }
+                        return [4 /*yield*/, this._getCurrentPlayheadPosition()];
+                    case 16:
+                        position = (_a.sent()) * 1000;
+                        timePosition = Date.now() - playheadState.playheadRef;
+                        // Apply time position offset if set, only after external diff compensation has concluded.
+                        if (this.timePositionOffset && this.diffCompensation <= 0 && this.alwaysNewSegments) {
+                            timePosition -= this.timePositionOffset;
+                            cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'applyTimePositionOffset', channel: this._sessionId, offsetMs: this.timePositionOffset });
+                        }
+                        diff = position - timePosition;
+                        debug("[".concat(this._sessionId, "]: ").concat(timePosition, ":").concat(position, ":").concat(diff > 0 ? '+' : '').concat(diff, "ms"));
+                        cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'playheadDiff', channel: this._sessionId, diffMs: diff });
+                        if (this.alwaysNewSegments) {
+                            // Apply Playhead diff compensation, only after external diff compensation has concluded.
+                            if (this.diffCompensation <= 0) {
+                                timeToAdd = this._getPlayheadDiffCompesationValue(diff, this.playheadDiffThreshold);
+                                tickInterval += timeToAdd;
+                            }
+                        }
+                        else {
+                            timeToAdd = this._getPlayheadDiffCompesationValue(diff, this.playheadDiffThreshold);
+                            tickInterval += timeToAdd;
+                        }
+                        // Apply external diff compensation if available.
+                        if (this.diffCompensation && this.diffCompensation > 0) {
+                            DIFF_COMPENSATION = (reqTickInterval * this.diffCompensationRate).toFixed(2) * 1000;
+                            debug("[".concat(this._sessionId, "]: Adding ").concat(DIFF_COMPENSATION, "msec to tickInterval to compensate for schedule diff (current=").concat(this.diffCompensation, "msec)"));
+                            tickInterval += (DIFF_COMPENSATION / 1000);
+                            this.diffCompensation -= DIFF_COMPENSATION;
+                        }
+                        // Keep tickInterval within upper and lower limits.
+                        debug("[".concat(this._sessionId, "]: Requested tickInterval=").concat(tickInterval, "s (max=").concat(this.maxTickInterval / 1000, "s, diffThreshold=").concat(this.playheadDiffThreshold, "msec)"));
+                        if (tickInterval <= 0.5) {
+                            tickInterval = 0.5;
+                        }
+                        else if (tickInterval > (this.maxTickInterval / 1000)) {
+                            changeMaxTick = Math.ceil(Math.abs(tickInterval * 1000 - (this.maxTickInterval))) + 1000;
+                            if (this.maxTickIntervalIsDefault) {
+                                if (numberOfLargeTicks > 2) {
+                                    this.maxTickInterval += changeMaxTick;
+                                    numberOfLargeTicks = 0;
+                                }
+                                else {
+                                    numberOfLargeTicks++;
+                                }
+                            }
+                            else {
+                                console.warn("[".concat(this._sessionId, "]: Playhead tick interval went over Max tick interval by ").concat(changeMaxTick, "ms.\n              If the value keeps increasing, consider increasing the 'maxTickInterval' in engineOptions"));
+                            }
+                            tickInterval = this.maxTickInterval / 1000;
+                        }
+                        debug("[".concat(this._sessionId, "]: (").concat((new Date()).toISOString(), ") ").concat(timeSpentInIncrement, "sec in increment. Next tick in ").concat(tickInterval, " seconds"));
+                        return [4 /*yield*/, timer((tickInterval * 1000) - 50)];
+                    case 17:
+                        _a.sent();
+                        tsTickEnd = Date.now();
+                        return [4 /*yield*/, this._playheadState.set("tickMs", (tsTickEnd - tsIncrementBegin))];
+                    case 18:
+                        _a.sent();
+                        cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'tickInterval', channel: this._sessionId, tickTimeMs: (tsTickEnd - tsIncrementBegin) });
+                        if (!this.alwaysNewSegments) return [3 /*break*/, 21];
+                        return [4 /*yield*/, this._getLastDuration(manifest)];
+                    case 19:
+                        lastDuration = _a.sent();
+                        nextTickInterval = lastDuration < 2 ? 2 : lastDuration;
+                        return [4 /*yield*/, this._playheadState.set("tickInterval", nextTickInterval)];
+                    case 20:
+                        _a.sent();
+                        cloudWatchLog(!this.cloudWatchLogging, "engine-session", { event: "tickIntervalUpdated", channel: this._sessionId, tickIntervalSec: nextTickInterval });
+                        _a.label = 21;
+                    case 21: return [3 /*break*/, 24];
+                    case 22:
+                        err_1 = _a.sent();
+                        debug("[".concat(this._sessionId, "]: Playhead consumer crashed (1)"));
+                        console.error("[".concat(this._sessionId, "]: ").concat(err_1.message));
+                        cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'error', on: 'playhead', channel: this._sessionId, err: err_1 });
+                        debug(err_1);
+                        return [4 /*yield*/, this._playheadState.setState(PlayheadState.CRASHED)];
+                    case 23:
+                        state = _a.sent();
+                        return [3 /*break*/, 24];
+                    case 24: return [3 /*break*/, 3];
+                    case 25: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Session.prototype.restartPlayheadAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_NEXT_INIT)];
+                    case 1:
+                        _a.sent();
+                        debug("[".concat(this._sessionId, "]: Restarting playhead consumer"));
+                        return [4 /*yield*/, this.startPlayheadAsync()];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Session.prototype.stopPlayheadAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        debug("[".concat(this._sessionId, "]: Stopping playhead consumer"));
+                        return [4 /*yield*/, this._playheadState.set("state", PlayheadState.STOPPED)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Session.prototype.getStatusAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var playheadState, state, sessionState, playheadStateMap, status_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.disabledPlayhead) return [3 /*break*/, 1];
+                        return [2 /*return*/, {
+                                sessionId: this._sessionId,
+                            }];
+                    case 1: return [4 /*yield*/, this._playheadState.getValues(["tickMs", "mediaSeq", "vodMediaSeqVideo"])];
+                    case 2:
+                        playheadState = _a.sent();
+                        return [4 /*yield*/, this._playheadState.getState()];
+                    case 3:
+                        state = _a.sent();
+                        return [4 /*yield*/, this._sessionState.getValues(["slateCount"])];
+                    case 4:
+                        sessionState = _a.sent();
+                        playheadStateMap = {};
+                        playheadStateMap[PlayheadState.IDLE] = 'idle';
+                        playheadStateMap[PlayheadState.RUNNING] = 'running';
+                        playheadStateMap[PlayheadState.CRASHED] = 'crashed';
+                        playheadStateMap[PlayheadState.STOPPED] = 'stopped';
+                        status_1 = {
+                            sessionId: this._sessionId,
+                            playhead: {
+                                state: playheadStateMap[state],
+                                tickMs: playheadState.tickMs,
+                                mediaSeq: playheadState.mediaSeq + playheadState.vodMediaSeqVideo,
+                            },
+                            slateInserted: sessionState.slateCount,
+                        };
+                        return [2 /*return*/, status_1];
+                }
+            });
+        });
+    };
+    Session.prototype.resetAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._sessionStateStore.reset(this._sessionId)];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this._playheadStateStore.reset(this._sessionId)];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Session.prototype.getSessionState = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var state;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._sessionState.get("state")];
+                    case 1:
+                        state = _a.sent();
+                        return [2 /*return*/, state];
+                }
+            });
+        });
+    };
+    Session.prototype.getTruncatedVodSegments = function (vodUri, duration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hlsVod, vodSegments_1, exc_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this._truncateSlate(null, duration, vodUri)];
+                    case 1:
+                        hlsVod = _a.sent();
+                        vodSegments_1 = hlsVod.getMediaSegments();
+                        Object.keys(vodSegments_1).forEach(function (bw) { return vodSegments_1[bw].unshift({ discontinuity: true, cue: { in: true } }); });
+                        return [2 /*return*/, vodSegments_1];
+                    case 2:
+                        exc_1 = _a.sent();
+                        debug("[".concat(this._sessionId, "]: Failed to generate truncated VOD!"));
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Session.prototype.setCurrentMediaSequenceSegments = function (segments, mSeqOffset, reloadBehind) {
+        return __awaiter(this, void 0, void 0, function () {
+            var waitTimeMs, i, isLeader, vodReloaded, attempts, vodReloaded, attempts;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._sessionState) {
+                            throw new Error("Session not ready");
+                        }
+                        this.isSwitchingBackToV2L = true;
+                        this.switchDataForSession.reloadBehind = reloadBehind;
+                        this.switchDataForSession.transitionSegments = segments;
+                        this.switchDataForSession.mediaSeqOffset = mSeqOffset;
+                        waitTimeMs = 2000;
+                        for (i = segments[Object.keys(segments)[0]].length - 1; 0 < i; i--) {
+                            if (segments[Object.keys(segments)[0]][i].duration) {
+                                waitTimeMs = parseInt(1000 * (segments[Object.keys(segments)[0]][i].duration / 3), 10);
+                                break;
+                            }
+                        }
+                        return [4 /*yield*/, this._sessionStateStore.isLeader(this._instanceId)];
+                    case 1:
+                        isLeader = _a.sent();
+                        if (!!isLeader) return [3 /*break*/, 13];
+                        debug("[".concat(this._sessionId, "]: FOLLOWER: Invalidate cache to ensure having the correct VOD!"));
+                        return [4 /*yield*/, this._sessionState.clearCurrentVodCache()];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, this._sessionState.get("vodReloaded")];
+                    case 3:
+                        vodReloaded = _a.sent();
+                        attempts = 9;
+                        _a.label = 4;
+                    case 4:
+                        if (!(!isLeader && !vodReloaded && attempts > 0)) return [3 /*break*/, 9];
+                        debug("[".concat(this._sessionId, "]: FOLLOWER: I arrived before LEADER. Waiting (1000ms) for LEADER to reload currentVod in store! (tries left=").concat(attempts, ")"));
+                        return [4 /*yield*/, timer(1000)];
+                    case 5:
+                        _a.sent();
+                        return [4 /*yield*/, this._sessionStateStore.clearLeaderCache()];
+                    case 6:
+                        _a.sent();
+                        return [4 /*yield*/, this._sessionStateStore.isLeader(this._instanceId)];
+                    case 7:
+                        isLeader = _a.sent();
+                        return [4 /*yield*/, this._sessionState.get("vodReloaded")];
+                    case 8:
+                        vodReloaded = _a.sent();
+                        attempts--;
+                        return [3 /*break*/, 4];
+                    case 9:
+                        if (attempts === 0) {
+                            debug("[".concat(this._sessionId, "]: FOLLOWER: WARNING! Attempts=0 - Risk of using wrong currentVod"));
+                        }
+                        if (!(!isLeader || vodReloaded)) return [3 /*break*/, 11];
+                        debug("[".concat(this._sessionId, "]: FOLLOWER: leader is alive, and has presumably updated currentVod. Clearing the cache now"));
+                        return [4 /*yield*/, this._sessionState.clearCurrentVodCache()];
+                    case 10:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 11:
+                        debug("[".concat(this._sessionId, "]: NEW LEADER: Setting state=VOD_RELOAD_INIT"));
+                        this.isSwitchingBackToV2L = true;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_RELOAD_INIT)];
+                    case 12:
+                        _a.sent();
+                        return [3 /*break*/, 19];
+                    case 13: return [4 /*yield*/, this._sessionState.get("vodReloaded")];
+                    case 14:
+                        vodReloaded = _a.sent();
+                        attempts = 12;
+                        _a.label = 15;
+                    case 15:
+                        if (!(!vodReloaded && attempts > 0)) return [3 /*break*/, 18];
+                        debug("[".concat(this._sessionId, "]: LEADER: Waiting (").concat(waitTimeMs, "ms) to buy some time reloading vod and adding it to store! (tries left=").concat(attempts, ")"));
+                        return [4 /*yield*/, timer(waitTimeMs)];
+                    case 16:
+                        _a.sent();
+                        return [4 /*yield*/, this._sessionState.get("vodReloaded")];
+                    case 17:
+                        vodReloaded = _a.sent();
+                        attempts--;
+                        return [3 /*break*/, 15];
+                    case 18:
+                        if (attempts === 0) {
+                            debug("[".concat(this._sessionId, "]: LEADER: WARNING! Vod was never Reloaded!"));
+                            return [2 /*return*/];
+                        }
+                        _a.label = 19;
+                    case 19: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Session.prototype.getCurrentMediaSequenceSegments = function (opts) {
+        return __awaiter(this, void 0, void 0, function () {
+            var isLeader, state, tries, waitTimeMs, playheadState, _a, currentVod, mediaSegments, mediaSequenceValue, err_2;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!this._sessionState) {
+                            throw new Error('Session not ready');
+                        }
+                        return [4 /*yield*/, this._sessionStateStore.isLeader(this._instanceId)];
+                    case 1:
+                        isLeader = _b.sent();
+                        if (!isLeader) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this._sessionState.set("vodReloaded", 0)];
+                    case 2:
+                        _b.sent();
+                        _b.label = 3;
+                    case 3: return [4 /*yield*/, this.getSessionState()];
+                    case 4:
+                        state = _b.sent();
+                        tries = 12;
+                        _b.label = 5;
+                    case 5:
+                        if (!(state !== SessionState.VOD_PLAYING && tries > 0)) return [3 /*break*/, 8];
+                        waitTimeMs = 500;
+                        debug("[".concat(this._sessionId, "]: state=").concat(state, " - Waiting ").concat(waitTimeMs, "ms_").concat(tries, " until Leader has finished loading next vod."));
+                        return [4 /*yield*/, timer(waitTimeMs)];
+                    case 6:
+                        _b.sent();
+                        tries--;
+                        return [4 /*yield*/, this.getSessionState()];
+                    case 7:
+                        state = _b.sent();
+                        return [3 /*break*/, 5];
+                    case 8:
+                        playheadState = {
+                            vodMediaSeqVideo: null
+                        };
+                        if (!(opts && opts.targetMseq !== undefined)) return [3 /*break*/, 9];
+                        playheadState.vodMediaSeqVideo = opts.targetMseq;
+                        return [3 /*break*/, 11];
+                    case 9:
+                        _a = playheadState;
+                        return [4 /*yield*/, this._playheadState.get("vodMediaSeqVideo")];
+                    case 10:
+                        _a.vodMediaSeqVideo = _b.sent();
+                        _b.label = 11;
+                    case 11: return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 12:
+                        currentVod = _b.sent();
+                        if (!currentVod) return [3 /*break*/, 17];
+                        _b.label = 13;
+                    case 13:
+                        _b.trys.push([13, 14, , 16]);
+                        mediaSegments = currentVod.getLiveMediaSequenceSegments(playheadState.vodMediaSeqVideo);
+                        mediaSequenceValue = 0;
+                        if (currentVod.sequenceAlwaysContainNewSegments) {
+                            mediaSequenceValue = currentVod.mediaSequenceValues[playheadState.vodMediaSeqVideo];
+                            debug("[".concat(this._sessionId, "]: {").concat(mediaSequenceValue, "}_{").concat(currentVod.getLastSequenceMediaSequenceValue(), "}"));
+                        }
+                        else {
+                            mediaSequenceValue = playheadState.vodMediaSeqVideo;
+                        }
+                        debug("[".concat(this._sessionId, "]: Requesting all segments from Media Sequence: ").concat(playheadState.vodMediaSeqVideo, "(").concat(mediaSequenceValue, ")_").concat(currentVod.getLiveMediaSequencesCount()));
+                        return [2 /*return*/, mediaSegments];
+                    case 14:
+                        err_2 = _b.sent();
+                        logerror(this._sessionId, err_2);
+                        return [4 /*yield*/, this._sessionState.clearCurrentVodCache()];
+                    case 15:
+                        _b.sent(); // force reading up from shared store
+                        throw new Error("Failed to get all current Media segments: " + JSON.stringify(playheadState));
+                    case 16: return [3 /*break*/, 18];
+                    case 17: throw new Error("Engine not ready");
+                    case 18: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Session.prototype.setCurrentMediaAndDiscSequenceCount = function (_mediaSeq, _discSeq) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (!this._sessionState) {
+                    throw new Error("Session not ready");
+                }
+                this.isSwitchingBackToV2L = true;
+                this.switchDataForSession.mediaSeq = _mediaSeq;
+                this.switchDataForSession.discSeq = _discSeq;
+                return [2 /*return*/];
+            });
+        });
+    };
+    Session.prototype.getCurrentMediaAndDiscSequenceCount = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var state, tries, waitTimeMs, playheadState, discSeqOffset, isLeader, currentVod, mediaSequenceValue, discSeqCount, err_3;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._sessionState) {
+                            throw new Error('Session not ready');
+                        }
+                        return [4 /*yield*/, this.getSessionState()];
+                    case 1:
+                        state = _a.sent();
+                        tries = 12;
+                        _a.label = 2;
+                    case 2:
+                        if (!(state !== SessionState.VOD_PLAYING && tries > 0)) return [3 /*break*/, 5];
+                        waitTimeMs = 500;
+                        debug("[".concat(this._sessionId, "]: state=").concat(state, " - Waiting ").concat(waitTimeMs, "ms_").concat(tries, " until Leader has finished loading next vod."));
+                        return [4 /*yield*/, timer(waitTimeMs)];
+                    case 3:
+                        _a.sent();
+                        tries--;
+                        return [4 /*yield*/, this.getSessionState()];
+                    case 4:
+                        state = _a.sent();
+                        return [3 /*break*/, 2];
+                    case 5: return [4 /*yield*/, this._playheadState.getValues(["mediaSeq", "vodMediaSeqVideo"])];
+                    case 6:
+                        playheadState = _a.sent();
+                        return [4 /*yield*/, this._sessionState.get("discSeq")];
+                    case 7:
+                        discSeqOffset = _a.sent();
+                        if (!(playheadState.vodMediaSeqVideo === 0)) return [3 /*break*/, 10];
+                        return [4 /*yield*/, this._sessionStateStore.isLeader(this._instanceId)];
+                    case 8:
+                        isLeader = _a.sent();
+                        if (!!isLeader) return [3 /*break*/, 10];
+                        debug("[".concat(this._sessionId, "]: Not a leader, about to switch, and first media sequence in a VOD is requested. Invalidate cache to ensure having the correct VOD."));
+                        return [4 /*yield*/, this._sessionState.clearCurrentVodCache()];
+                    case 9:
+                        _a.sent(); // force reading up from shared store
+                        _a.label = 10;
+                    case 10: return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 11:
+                        currentVod = _a.sent();
+                        if (!currentVod) return [3 /*break*/, 16];
+                        _a.label = 12;
+                    case 12:
+                        _a.trys.push([12, 13, , 15]);
+                        mediaSequenceValue = 0;
+                        if (currentVod.sequenceAlwaysContainNewSegments) {
+                            mediaSequenceValue = currentVod.mediaSequenceValues[playheadState.vodMediaSeqVideo];
+                            debug("[".concat(this._sessionId, "]: seqIndex=").concat(playheadState.vodMediaSeqVideo, "_seqValue=").concat(mediaSequenceValue));
+                        }
+                        else {
+                            mediaSequenceValue = playheadState.vodMediaSeqVideo;
+                        }
+                        discSeqCount = discSeqOffset + currentVod.discontinuities[playheadState.vodMediaSeqVideo];
+                        debug("[".concat(this._sessionId, "]: MediaSeq: (").concat(playheadState.mediaSeq, "+").concat(mediaSequenceValue, "=").concat((playheadState.mediaSeq + mediaSequenceValue), ") and DiscSeq: (").concat(discSeqCount, ") requested "));
+                        return [2 /*return*/, {
+                                'mediaSeq': (playheadState.mediaSeq + mediaSequenceValue),
+                                'discSeq': discSeqCount,
+                                'vodMediaSeqVideo': playheadState.vodMediaSeqVideo,
+                            }];
+                    case 13:
+                        err_3 = _a.sent();
+                        logerror(this._sessionId, err_3);
+                        return [4 /*yield*/, this._sessionState.clearCurrentVodCache()];
+                    case 14:
+                        _a.sent(); // force reading up from shared store
+                        throw new Error("Failed to get states: " + JSON.stringify(playheadState));
+                    case 15: return [3 /*break*/, 17];
+                    case 16: throw new Error("Engine not ready");
+                    case 17: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Session.prototype.getCurrentMediaManifestAsync = function (bw, playbackSessionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tries, sessionState, playheadState, state, m3u8_1, isLeader, diffMs, currentVod, manifestMseq, manifestDseq, mediaSequenceValue, m3u8_2, err_4;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._sessionState) {
+                            throw new Error('Session not ready');
+                        }
+                        tries = 12;
+                        _a.label = 1;
+                    case 1:
+                        if (!(tries > 0 && this.leaderIsSettingNextVod)) return [3 /*break*/, 3];
+                        debug("[".concat(this._sessionId, "]: Leader is setting the next vod. Waiting 500ms_").concat(tries));
+                        return [4 /*yield*/, timer(500)];
+                    case 2:
+                        _a.sent();
+                        tries--;
+                        return [3 /*break*/, 1];
+                    case 3: return [4 /*yield*/, this._sessionState.getValues(["vodMediaSeqVideo", "discSeq"])];
+                    case 4:
+                        sessionState = _a.sent();
+                        return [4 /*yield*/, this._playheadState.getValues(["mediaSeq", "vodMediaSeqVideo"])];
+                    case 5:
+                        playheadState = _a.sent();
+                        if (this.prevVodMediaSeq.video === null) {
+                            this.prevVodMediaSeq.video = playheadState.vodMediaSeqVideo;
+                        }
+                        if (this.prevMediaSeqOffset.video === null) {
+                            this.prevMediaSeqOffset.video = playheadState.mediaSeq;
+                        }
+                        if (!(playheadState.vodMediaSeqVideo > sessionState.vodMediaSeqVideo ||
+                            (playheadState.vodMediaSeqVideo < sessionState.vodMediaSeqVideo &&
+                                playheadState.mediaSeq === this.prevMediaSeqOffset.video))) return [3 /*break*/, 11];
+                        return [4 /*yield*/, this._sessionState.get("state")];
+                    case 6:
+                        state = _a.sent();
+                        if (![SessionState.VOD_RELOAD_INIT, SessionState.VOD_RELOAD_INITIATING].includes(state)) return [3 /*break*/, 9];
+                        debug("[".concat(this._sessionId, "]: Recently reloaded Vod. PlayheadState not up-to-date (").concat(playheadState.vodMediaSeqVideo, "_").concat(sessionState.vodMediaSeqVideo, "). Waiting 500ms before reading from store again"));
+                        return [4 /*yield*/, timer(500)];
+                    case 7:
+                        _a.sent();
+                        return [4 /*yield*/, this._playheadState.getValues(["mediaSeq", "vodMediaSeqVideo"])];
+                    case 8:
+                        playheadState = _a.sent();
+                        return [3 /*break*/, 11];
+                    case 9:
+                        debug("[".concat(this._sessionId, "]: Recently Loaded Next Vod. PlayheadState not up-to-date. Return the last generated m3u8"));
+                        return [4 /*yield*/, this._playheadState.getLastM3u8()];
+                    case 10:
+                        m3u8_1 = _a.sent();
+                        if (m3u8_1) {
+                            this.prevVodMediaSeq.video = playheadState.vodMediaSeqVideo;
+                            return [2 /*return*/, m3u8_1];
+                        }
+                        else {
+                            debug("[".concat(this._sessionId, "]: We don't have any previously generated m3u8"));
+                        }
+                        _a.label = 11;
+                    case 11:
+                        if (!(playheadState.vodMediaSeqVideo < 2 || playheadState.mediaSeq !== this.prevMediaSeqOffset.video)) return [3 /*break*/, 16];
+                        debug("[".concat(this._sessionId, "]: current[").concat(playheadState.vodMediaSeqVideo, "]_prev[").concat(this.prevVodMediaSeq.video, "]"));
+                        debug("[".concat(this._sessionId, "]: current-offset[").concat(playheadState.mediaSeq, "]_prev-offset[").concat(this.prevMediaSeqOffset.video, "]"));
+                        // If true, then we have not updated the prev-values and not cleared the cache yet.
+                        if (playheadState.vodMediaSeqVideo < this.prevVodMediaSeq.video || playheadState.mediaSeq !== this.prevMediaSeqOffset.video) {
+                            this.isAllowedToClearVodCache = true;
+                        }
+                        return [4 /*yield*/, this._sessionStateStore.isLeader(this._instanceId)];
+                    case 12:
+                        isLeader = _a.sent();
+                        if (!(!isLeader && this.isAllowedToClearVodCache)) return [3 /*break*/, 15];
+                        debug("[".concat(this._sessionId, "]: Not a leader and first|second media sequence in a VOD is requested. Invalidate cache to ensure having the correct VOD."));
+                        return [4 /*yield*/, this._sessionState.clearCurrentVodCache()];
+                    case 13:
+                        _a.sent();
+                        this.isAllowedToClearVodCache = false;
+                        return [4 /*yield*/, this._playheadState.get("diffCompensation")];
+                    case 14:
+                        diffMs = _a.sent();
+                        if (diffMs) {
+                            this.diffCompensation = diffMs;
+                            debug("[".concat(this._sessionId, "]: Setting diffCompensation->").concat(this.diffCompensation));
+                            if (this.diffCompensation) {
+                                this.timePositionOffset = this.diffCompensation;
+                                cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'timePositionOffsetUpdated', channel: this._sessionId, offsetMs: this.timePositionOffset });
+                            }
+                            else {
+                                this.timePositionOffset = 0;
+                            }
+                        }
+                        _a.label = 15;
+                    case 15: return [3 /*break*/, 17];
+                    case 16:
+                        this.isAllowedToClearVodCache = true;
+                        _a.label = 17;
+                    case 17: return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 18:
+                        currentVod = _a.sent();
+                        if (!currentVod) return [3 /*break*/, 23];
+                        _a.label = 19;
+                    case 19:
+                        _a.trys.push([19, 20, , 22]);
+                        manifestMseq = playheadState.mediaSeq + playheadState.vodMediaSeqVideo;
+                        manifestDseq = sessionState.discSeq + currentVod.discontinuities[playheadState.vodMediaSeqVideo];
+                        if (currentVod.sequenceAlwaysContainNewSegments) {
+                            mediaSequenceValue = currentVod.mediaSequenceValues[playheadState.vodMediaSeqVideo];
+                            debug("[".concat(this._sessionId, "]: {").concat(mediaSequenceValue, "}_{").concat(currentVod.getLastSequenceMediaSequenceValue(), "}"));
+                            manifestMseq = playheadState.mediaSeq + mediaSequenceValue;
+                        }
+                        debug("[".concat(this._sessionId, "]: [").concat(playheadState.vodMediaSeqVideo, "]_[").concat(currentVod.getLiveMediaSequencesCount(), "]"));
+                        m3u8_2 = currentVod.getLiveMediaSequences(playheadState.mediaSeq, bw, playheadState.vodMediaSeqVideo, sessionState.discSeq, this.targetDurationPadding, this.forceTargetDuration);
+                        debug("[".concat(this._sessionId, "]: [").concat(manifestMseq, "][").concat(manifestDseq, "][+").concat(this.targetDurationPadding || 0, "] Current media manifest for ").concat(bw, " requested"));
+                        this.prevVodMediaSeq.video = playheadState.vodMediaSeqVideo;
+                        this.prevMediaSeqOffset.video = playheadState.mediaSeq;
+                        return [2 /*return*/, m3u8_2];
+                    case 20:
+                        err_4 = _a.sent();
+                        logerror(this._sessionId, err_4);
+                        return [4 /*yield*/, this._sessionState.clearCurrentVodCache()];
+                    case 21:
+                        _a.sent(); // force reading up from shared store
+                        throw new Error("Failed to generate manifest: " + JSON.stringify(playheadState));
+                    case 22: return [3 /*break*/, 24];
+                    case 23: throw new Error("Engine not ready");
+                    case 24: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Session.prototype.getCurrentAudioManifestAsync = function (audioGroupId, audioLanguage, playbackSessionId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sessionState, playheadState, currentVod, m3u8_3, err_5;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this._sessionState) {
+                            throw new Error('Session not ready');
+                        }
+                        return [4 /*yield*/, this._sessionState.getValues(["discSeq"])];
+                    case 1:
+                        sessionState = _a.sent();
+                        return [4 /*yield*/, this._playheadState.getValues(["mediaSeq", "vodMediaSeqAudio"])];
+                    case 2:
+                        playheadState = _a.sent();
+                        return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 3:
+                        currentVod = _a.sent();
+                        if (!currentVod) return [3 /*break*/, 8];
+                        _a.label = 4;
+                    case 4:
+                        _a.trys.push([4, 5, , 7]);
+                        m3u8_3 = currentVod.getLiveMediaAudioSequences(playheadState.mediaSeq, audioGroupId, audioLanguage, playheadState.vodMediaSeqAudio, sessionState.discSeq, this.targetDurationPadding, this.forceTargetDuration);
+                        // # Case: current VOD does not have the selected track.
+                        if (!m3u8_3) {
+                            debug("[".concat(this._sessionId, "]: [").concat(playheadState.mediaSeq + playheadState.vodMediaSeqAudio, "] Request Failed for current audio manifest for ").concat(audioGroupId, "-").concat(audioLanguage));
+                        }
+                        debug("[".concat(this._sessionId, "]: [").concat(playheadState.mediaSeq + playheadState.vodMediaSeqAudio, "] Current audio manifest for ").concat(audioGroupId, "-").concat(audioLanguage, " requested"));
+                        return [2 /*return*/, m3u8_3];
+                    case 5:
+                        err_5 = _a.sent();
+                        logerror(this._sessionId, err_5);
+                        return [4 /*yield*/, this._sessionState.clearCurrentVodCache()];
+                    case 6:
+                        _a.sent(); // force reading up from shared store
+                        throw new Error("Failed to generate audio manifest: " + JSON.stringify(playheadState));
+                    case 7: return [3 /*break*/, 9];
+                    case 8: throw new Error("Engine not ready");
+                    case 9: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Session.prototype.incrementAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var isLeader, sessionState, playheadState, currentVod, _a, leaderAction, _b, m3u8_4, _c, _d, _e, _f, _g, _h, _j, _k, _l, mediaSequenceValue, diffMs, m3u8;
+            return __generator(this, function (_m) {
+                switch (_m.label) {
+                    case 0: return [4 /*yield*/, this._tickAsync()];
+                    case 1:
+                        _m.sent();
+                        return [4 /*yield*/, this._sessionStateStore.isLeader(this._instanceId)];
+                    case 2:
+                        isLeader = _m.sent();
+                        return [4 /*yield*/, this._sessionState.getValues(["state", "mediaSeq", "discSeq", "vodMediaSeqVideo", "vodMediaSeqAudio"])];
+                    case 3:
+                        sessionState = _m.sent();
+                        return [4 /*yield*/, this._playheadState.getValues(["mediaSeq", "vodMediaSeqVideo", "vodMediaSeqAudio"])];
+                    case 4:
+                        playheadState = _m.sent();
+                        return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 5:
+                        currentVod = _m.sent();
+                        if (!(!currentVod ||
+                            sessionState.vodMediaSeqVideo === null ||
+                            sessionState.vodMediaSeqAudio === null ||
+                            sessionState.state === null ||
+                            sessionState.mediaSeq === null ||
+                            sessionState.discSeq === null)) return [3 /*break*/, 9];
+                        debug("[".concat(this._sessionId, "]: Session is not ready yet"));
+                        debug(sessionState);
+                        return [4 /*yield*/, this._sessionState.clearCurrentVodCache()];
+                    case 6:
+                        _m.sent();
+                        if (!isLeader) return [3 /*break*/, 8];
+                        debug("[".concat(this._sessionId, "]: I am the leader, trying to initiate the session"));
+                        _a = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_INIT)];
+                    case 7:
+                        _a.state = _m.sent();
+                        _m.label = 8;
+                    case 8: return [2 /*return*/, null];
+                    case 9:
+                        if (!(sessionState.state === SessionState.VOD_NEXT_INITIATING || sessionState.state === SessionState.VOD_RELOAD_INITIATING)) return [3 /*break*/, 14];
+                        if (!isLeader) return [3 /*break*/, 11];
+                        leaderAction = sessionState.state === SessionState.VOD_NEXT_INITIATING ? "initiated" : "reloaded";
+                        debug("[".concat(this._sessionId, "]: I am the leader and have just ").concat(leaderAction, " next VOD, let's move to VOD_PLAYING"));
+                        _b = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_PLAYING)];
+                    case 10:
+                        _b.state = _m.sent();
+                        return [3 /*break*/, 13];
+                    case 11:
+                        debug("[".concat(this._sessionId, "]: Return the last generated m3u8 to give the leader some time"));
+                        return [4 /*yield*/, this._playheadState.getLastM3u8()];
+                    case 12:
+                        m3u8_4 = _m.sent();
+                        if (m3u8_4) {
+                            return [2 /*return*/, m3u8_4];
+                        }
+                        else {
+                            debug("[".concat(this._sessionId, "]: We don't have any previously generated m3u8"));
+                        }
+                        this.isAllowedToClearVodCache = true;
+                        _m.label = 13;
+                    case 13: return [3 /*break*/, 17];
+                    case 14:
+                        _c = sessionState;
+                        return [4 /*yield*/, this._sessionState.increment("vodMediaSeqVideo")];
+                    case 15:
+                        _c.vodMediaSeqVideo = _m.sent();
+                        _d = sessionState;
+                        return [4 /*yield*/, this._sessionState.increment("vodMediaSeqAudio")];
+                    case 16:
+                        _d.vodMediaSeqAudio = _m.sent();
+                        _m.label = 17;
+                    case 17:
+                        if (!(sessionState.vodMediaSeqVideo >= currentVod.getLiveMediaSequencesCount() - 1)) return [3 /*break*/, 21];
+                        _e = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqVideo", currentVod.getLiveMediaSequencesCount() - 1)];
+                    case 18:
+                        _e.vodMediaSeqVideo = _m.sent();
+                        _f = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqAudio", currentVod.getLiveMediaSequencesCount() - 1)];
+                    case 19:
+                        _f.vodMediaSeqAudio = _m.sent();
+                        _g = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_NEXT_INIT)];
+                    case 20:
+                        _g.state = _m.sent();
+                        _m.label = 21;
+                    case 21:
+                        if (!this.isSwitchingBackToV2L) return [3 /*break*/, 23];
+                        _h = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_RELOAD_INIT)];
+                    case 22:
+                        _h.state = _m.sent();
+                        this.isSwitchingBackToV2L = false;
+                        _m.label = 23;
+                    case 23:
+                        _j = playheadState;
+                        return [4 /*yield*/, this._playheadState.set("mediaSeq", sessionState.mediaSeq)];
+                    case 24:
+                        _j.mediaSeq = _m.sent();
+                        _k = playheadState;
+                        return [4 /*yield*/, this._playheadState.set("vodMediaSeqVideo", sessionState.vodMediaSeqVideo)];
+                    case 25:
+                        _k.vodMediaSeqVideo = _m.sent();
+                        _l = playheadState;
+                        return [4 /*yield*/, this._playheadState.set("vodMediaSeqAudio", sessionState.vodMediaSeqAudio)];
+                    case 26:
+                        _l.vodMediaSeqAudio = _m.sent();
+                        if (currentVod.sequenceAlwaysContainNewSegments) {
+                            mediaSequenceValue = currentVod.mediaSequenceValues[playheadState.vodMediaSeqVideo];
+                            debug("[".concat(this._sessionId, "]: Session can now serve mseq={").concat(playheadState.mediaSeq + mediaSequenceValue, "}"));
+                        }
+                        debug("[".concat(this._sessionId, "]: INCREMENT (mseq=").concat(playheadState.mediaSeq + playheadState.vodMediaSeqVideo, ") vodMediaSeq=(").concat(playheadState.vodMediaSeqVideo, "_").concat(playheadState.vodMediaSeqAudio, " of ").concat(currentVod.getLiveMediaSequencesCount(), ")"));
+                        if (!(playheadState.vodMediaSeqVideo < 2 || playheadState.mediaSeq !== this.prevMediaSeqOffset.video)) return [3 /*break*/, 31];
+                        debug("[".concat(this._sessionId, "]: current[").concat(playheadState.vodMediaSeqVideo, "]_prev[").concat(this.prevVodMediaSeq.video, "]"));
+                        debug("[".concat(this._sessionId, "]: current-offset[").concat(playheadState.mediaSeq, "]_prev-offset[").concat(this.prevMediaSeqOffset.video, "]"));
+                        if (playheadState.vodMediaSeqVideo < this.prevVodMediaSeq.video || playheadState.mediaSeq !== this.prevMediaSeqOffset.video) {
+                            this.isAllowedToClearVodCache = true;
+                        }
+                        if (!(!isLeader && this.isAllowedToClearVodCache)) return [3 /*break*/, 30];
+                        debug("[".concat(this._sessionId, "]: Not a leader and have just set 'playheadState.vodMediaSeqVideo' to 0|1. Invalidate cache to ensure having the correct VOD."));
+                        return [4 /*yield*/, this._sessionState.clearCurrentVodCache()];
+                    case 27:
+                        _m.sent();
+                        return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 28:
+                        currentVod = _m.sent();
+                        return [4 /*yield*/, this._playheadState.get("diffCompensation")];
+                    case 29:
+                        diffMs = _m.sent();
+                        if (diffMs) {
+                            this.diffCompensation = diffMs;
+                            debug("[".concat(this._sessionId, "]: Setting diffCompensation->").concat(this.diffCompensation));
+                            if (this.diffCompensation) {
+                                this.timePositionOffset = this.diffCompensation;
+                                cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'timePositionOffsetUpdated', channel: this._sessionId, offsetMs: this.timePositionOffset });
+                            }
+                            else {
+                                this.timePositionOffset = 0;
+                            }
+                        }
+                        this.isAllowedToClearVodCache = false;
+                        _m.label = 30;
+                    case 30: return [3 /*break*/, 32];
+                    case 31:
+                        this.isAllowedToClearVodCache = true;
+                        _m.label = 32;
+                    case 32:
+                        // Update Value for Previous Sequence
+                        this.prevVodMediaSeq.video = playheadState.vodMediaSeqVideo;
+                        this.prevMediaSeqOffset.video = playheadState.mediaSeq;
+                        m3u8 = currentVod.getLiveMediaSequences(playheadState.mediaSeq, 180000, playheadState.vodMediaSeqVideo, sessionState.discSeq);
+                        return [4 /*yield*/, this._playheadState.setLastM3u8(m3u8)];
+                    case 33:
+                        _m.sent();
+                        return [2 /*return*/, m3u8];
+                }
+            });
+        });
+    };
+    Session.prototype.getMediaManifestAsync = function (bw, opts) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tsLastRequestVideo, timeSinceLastRequest, sessionState, currentVod, _a, sequencesToIncrement, _b, _c, _d, m3u8, lastM3u8, _e, _f, _g, tsLastRequestVideo_1, timeSinceLastRequest_1, sessionState_1, _h, lastM3u8_1, _j, _k, _l;
+            return __generator(this, function (_m) {
+                switch (_m.label) {
+                    case 0: return [4 /*yield*/, this._tickAsync()];
+                    case 1:
+                        _m.sent();
+                        return [4 /*yield*/, this._sessionState.get("tsLastRequestVideo")];
+                    case 2:
+                        tsLastRequestVideo = _m.sent();
+                        timeSinceLastRequest = (tsLastRequestVideo === null) ? 0 : Date.now() - tsLastRequestVideo;
+                        return [4 /*yield*/, this._sessionState.getValues(["state", "vodMediaSeqVideo", "mediaSeq", "discSeq", "lastM3u8"])];
+                    case 3:
+                        sessionState = _m.sent();
+                        return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 4:
+                        currentVod = _m.sent();
+                        if (!currentVod) {
+                            throw new Error('Session not ready');
+                        }
+                        if (!(sessionState.state === SessionState.VOD_NEXT_INITIATING)) return [3 /*break*/, 6];
+                        _a = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_PLAYING)];
+                    case 5:
+                        _a.state = _m.sent();
+                        return [3 /*break*/, 8];
+                    case 6:
+                        sequencesToIncrement = Math.ceil(timeSinceLastRequest / this.averageSegmentDuration);
+                        _b = sessionState;
+                        return [4 /*yield*/, this._sessionState.increment("vodMediaSeqVideo", sequencesToIncrement)];
+                    case 7:
+                        _b.vodMediaSeqVideo = _m.sent();
+                        _m.label = 8;
+                    case 8:
+                        if (!(sessionState.vodMediaSeqVideo >= currentVod.getLiveMediaSequencesCount() - 1)) return [3 /*break*/, 11];
+                        _c = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqVideo", currentVod.getLiveMediaSequencesCount() - 1)];
+                    case 9:
+                        _c.vodMediaSeqVideo = _m.sent();
+                        _d = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_NEXT_INIT)];
+                    case 10:
+                        _d.state = _m.sent();
+                        _m.label = 11;
+                    case 11:
+                        debug("[".concat(this._sessionId, "]: VIDEO ").concat(timeSinceLastRequest, " (").concat(this.averageSegmentDuration, ") bandwidth=").concat(bw, " vodMediaSeq=(").concat(sessionState.vodMediaSeqVideo, "_").concat(sessionState.vodMediaSeqAudio, ")"));
+                        try {
+                            m3u8 = currentVod.getLiveMediaSequences(sessionState.mediaSeq, bw, sessionState.vodMediaSeqVideo, sessionState.discSeq);
+                        }
+                        catch (exc) {
+                            if (sessionState.lastM3u8[bw]) {
+                                m3u8 = sessionState.lastM3u8[bw];
+                            }
+                            else {
+                                logerror(this._sessionId, exc);
+                                throw new Error('Failed to generate media manifest');
+                            }
+                        }
+                        lastM3u8 = sessionState.lastM3u8;
+                        lastM3u8[bw] = m3u8;
+                        _e = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("lastM3u8", lastM3u8)];
+                    case 12:
+                        _e.lastM3u8 = _m.sent();
+                        _f = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("lastServedM3u8", m3u8)];
+                    case 13:
+                        _f.lastServedM3u8 = _m.sent();
+                        _g = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("tsLastRequestVideo", Date.now())];
+                    case 14:
+                        _g.tsLastRequestVideo = _m.sent();
+                        if (!(sessionState.state === SessionState.VOD_NEXT_INIT)) return [3 /*break*/, 23];
+                        return [4 /*yield*/, this._tickAsync()];
+                    case 15:
+                        _m.sent();
+                        return [4 /*yield*/, this._sessionState.get("tsLastRequestVideo")];
+                    case 16:
+                        tsLastRequestVideo_1 = _m.sent();
+                        timeSinceLastRequest_1 = (tsLastRequestVideo_1 === null) ? 0 : Date.now() - tsLastRequestVideo_1;
+                        return [4 /*yield*/, this._sessionState.getValues(["state", "vodMediaSeqVideo", "mediaSeq", "discSeq", "lastM3u8"])];
+                    case 17:
+                        sessionState_1 = _m.sent();
+                        if (!(sessionState_1.state === SessionState.VOD_NEXT_INITIATING)) return [3 /*break*/, 19];
+                        _h = sessionState_1;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_PLAYING)];
+                    case 18:
+                        _h.state = _m.sent();
+                        _m.label = 19;
+                    case 19:
+                        debug("[".concat(this._sessionId, "]: VIDEO ").concat(timeSinceLastRequest_1, " (").concat(this.averageSegmentDuration, ") bandwidth=").concat(bw, " vodMediaSeq=(").concat(sessionState_1.vodMediaSeqVideo, "_").concat(sessionState_1.vodMediaSeqAudio, ")"));
+                        try {
+                            m3u8 = currentVod.getLiveMediaSequences(sessionState_1.mediaSeq, bw, sessionState_1.vodMediaSeqVideo, sessionState_1.discSeq);
+                        }
+                        catch (exc) {
+                            if (sessionState_1.lastM3u8[bw]) {
+                                m3u8 = sessionState_1.lastM3u8[bw];
+                            }
+                            else {
+                                logerror(this._sessionId, exc);
+                                throw new Error('Failed to generate media manifest');
+                            }
+                        }
+                        lastM3u8_1 = sessionState_1.lastM3u8;
+                        lastM3u8_1[bw] = m3u8;
+                        _j = sessionState_1;
+                        return [4 /*yield*/, this._sessionState.set("lastM3u8", lastM3u8_1)];
+                    case 20:
+                        _j.lastM3u8 = _m.sent();
+                        _k = sessionState_1;
+                        return [4 /*yield*/, this._sessionState.set("lastServedM3u8", m3u8)];
+                    case 21:
+                        _k.lastServedM3u8 = _m.sent();
+                        _l = sessionState_1;
+                        return [4 /*yield*/, this._sessionState.set("tsLastRequestVideo", Date.now())];
+                    case 22:
+                        _l.tsLastRequestVideo = _m.sent();
+                        return [2 /*return*/, m3u8];
+                    case 23: return [2 /*return*/, m3u8];
+                }
+            });
+        });
+    };
+    Session.prototype.getAudioManifestAsync = function (audioGroupId, audioLanguage, opts) {
+        return __awaiter(this, void 0, void 0, function () {
+            var tsLastRequestAudio, timeSinceLastRequest, sessionState, currentVod, sequencesToIncrement, _a, _b, m3u8, lastM3u8, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0: return [4 /*yield*/, this._sessionState.get("tsLastRequestAudio")];
+                    case 1:
+                        tsLastRequestAudio = _e.sent();
+                        timeSinceLastRequest = (tsLastRequestAudio === null) ? 0 : Date.now() - tsLastRequestAudio;
+                        return [4 /*yield*/, this._sessionState.getValues(["state", "vodMediaSeqVideo", "vodMediaSeqAudio", "mediaSeq", "discSeq", "lastM3u8"])];
+                    case 2:
+                        sessionState = _e.sent();
+                        return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 3:
+                        currentVod = _e.sent();
+                        if (!(sessionState.state !== SessionState.VOD_NEXT_INITIATING)) return [3 /*break*/, 6];
+                        sequencesToIncrement = Math.ceil(timeSinceLastRequest / this.averageSegmentDuration);
+                        if (!(sessionState.vodMediaSeqAudio < sessionState.vodMediaSeqVideo)) return [3 /*break*/, 6];
+                        _a = sessionState;
+                        return [4 /*yield*/, this._sessionState.increment("vodMediaSeqAudio", sequencesToIncrement)];
+                    case 4:
+                        _a.vodMediaSeqAudio = _e.sent();
+                        if (!(sessionState.vodMediaSeqAudio >= currentVod.getLiveMediaSequencesCount() - 1)) return [3 /*break*/, 6];
+                        _b = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqAudio", currentVod.getLiveMediaSequencesCount() - 1)];
+                    case 5:
+                        _b.vodMediaSeqAudio = _e.sent();
+                        _e.label = 6;
+                    case 6:
+                        debug("[".concat(this._sessionId, "]: AUDIO ").concat(timeSinceLastRequest, " (").concat(this.averageSegmentDuration, ") audioGroupId=").concat(audioGroupId, " audioLanguage=").concat(audioLanguage, " vodMediaSeq=(").concat(sessionState.vodMediaSeqVideo, "_").concat(sessionState.vodMediaSeqAudio, ")"));
+                        try {
+                            m3u8 = currentVod.getLiveMediaAudioSequences(sessionState.mediaSeq, audioGroupId, audioLanguage, sessionState.vodMediaSeqAudio, sessionState.discSeq);
+                        }
+                        catch (exc) {
+                            if (sessionState.lastM3u8[audioGroupId][audioLanguage]) {
+                                m3u8 = sessionState.lastM3u8[audioGroupId][audioLanguage];
+                            }
+                            else {
+                                logerror(this._sessionId, exc);
+                                throw new Error('Failed to generate audio manifest');
+                            }
+                        }
+                        lastM3u8 = sessionState.lastM3u8;
+                        lastM3u8[audioGroupId] = {};
+                        lastM3u8[audioGroupId][audioLanguage] = m3u8;
+                        _c = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("lastM3u8", lastM3u8)];
+                    case 7:
+                        _c.lastM3u8 = _e.sent();
+                        _d = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("tsLastRequestAudio", Date.now())];
+                    case 8:
+                        _d.tsLastRequestAudio = _e.sent();
+                        return [2 /*return*/, m3u8];
+                }
+            });
+        });
+    };
+    Session.prototype.getMasterManifestAsync = function (filter) {
+        return __awaiter(this, void 0, void 0, function () {
+            var m3u8, currentVod, audioGroupIds, defaultAudioGroupId, hasClosedCaptions, i, audioGroupId, j, audioTrack, sessionProfile, i, audioGroupId, j, audioTrack;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        m3u8 = "#EXTM3U\n";
+                        m3u8 += "#EXT-X-VERSION:4\n";
+                        m3u8 += m3u8Header(this._instanceId);
+                        m3u8 += "#EXT-X-SESSION-DATA:DATA-ID=\"eyevinn.tv.session.id\",VALUE=\"".concat(this._sessionId, "\"\n");
+                        m3u8 += "#EXT-X-SESSION-DATA:DATA-ID=\"eyevinn.tv.eventstream\",VALUE=\"/eventstream/".concat(this._sessionId, "\"\n");
+                        return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 1:
+                        currentVod = _a.sent();
+                        if (!currentVod) {
+                            throw new Error('Session not ready');
+                        }
+                        audioGroupIds = currentVod.getAudioGroups();
+                        hasClosedCaptions = this._closedCaptions && this._closedCaptions.length > 0;
+                        if (hasClosedCaptions) {
+                            this._closedCaptions.forEach(function (cc) {
+                                m3u8 += "#EXT-X-MEDIA:TYPE=CLOSED-CAPTIONS,GROUP-ID=\"cc\",LANGUAGE=\"".concat(cc.lang, "\",NAME=\"").concat(cc.name, "\",DEFAULT=").concat(cc.default ? "YES" : "NO", ",AUTOSELECT=").concat(cc.auto ? "YES" : "NO", ",INSTREAM-ID=\"").concat(cc.id, "\"\n");
+                            });
+                        }
+                        if (this.use_demuxed_audio === true && this._audioTracks) {
+                            if (audioGroupIds.length > 0) {
+                                m3u8 += "# AUDIO groups\n";
+                                for (i = 0; i < audioGroupIds.length; i++) {
+                                    audioGroupId = audioGroupIds[i];
+                                    for (j = 0; j < this._audioTracks.length; j++) {
+                                        audioTrack = this._audioTracks[j];
+                                        // Make default track if set property is true.
+                                        if (audioTrack.default) {
+                                            m3u8 += "#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID=\"".concat(audioGroupId, "\",LANGUAGE=\"").concat(audioTrack.language, "\", NAME=\"").concat(audioTrack.name, "\",AUTOSELECT=YES,DEFAULT=YES,CHANNELS=\"2\",URI=\"master-").concat(audioGroupId, "_").concat(audioTrack.language, ".m3u8;session=").concat(this._sessionId, "\"\n");
+                                        }
+                                        else {
+                                            m3u8 += "#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID=\"".concat(audioGroupId, "\",LANGUAGE=\"").concat(audioTrack.language, "\", NAME=\"").concat(audioTrack.name, "\",AUTOSELECT=YES,DEFAULT=NO,CHANNELS=\"2\",URI=\"master-").concat(audioGroupId, "_").concat(audioTrack.language, ".m3u8;session=").concat(this._sessionId, "\"\n");
+                                        }
+                                    }
+                                }
+                                // As of now, by default set StreamItem's AUDIO attribute to <first audio group-id>
+                                defaultAudioGroupId = audioGroupIds[0];
+                            }
+                        }
+                        if (this._sessionProfile) {
+                            sessionProfile = filter ? applyFilter(this._sessionProfile, filter) : this._sessionProfile;
+                            sessionProfile.forEach(function (profile) {
+                                m3u8 += '#EXT-X-STREAM-INF:BANDWIDTH=' + profile.bw + ',RESOLUTION=' + profile.resolution[0] + 'x' + profile.resolution[1] + ',CODECS="' + profile.codecs + '"' + (defaultAudioGroupId ? ",AUDIO=\"".concat(defaultAudioGroupId, "\"") : '') + (hasClosedCaptions ? ',CLOSED-CAPTIONS="cc"' : '') + '\n';
+                                m3u8 += "master" + profile.bw + ".m3u8;session=" + _this._sessionId + "\n";
+                            });
+                        }
+                        else {
+                            currentVod.getUsageProfiles().forEach(function (profile) {
+                                m3u8 += '#EXT-X-STREAM-INF:BANDWIDTH=' + profile.bw + ',RESOLUTION=' + profile.resolution + ',CODECS="' + profile.codecs + '"' + (defaultAudioGroupId ? ",AUDIO=\"".concat(defaultAudioGroupId, "\"") : '') + (hasClosedCaptions ? ',CLOSED-CAPTIONS="cc"' : '') + '\n';
+                                m3u8 += "master" + profile.bw + ".m3u8;session=" + _this._sessionId + "\n";
+                            });
+                        }
+                        if (this.use_demuxed_audio === true && this._audioTracks) {
+                            for (i = 0; i < audioGroupIds.length; i++) {
+                                audioGroupId = audioGroupIds[i];
+                                for (j = 0; j < this._audioTracks.length; j++) {
+                                    audioTrack = this._audioTracks[j];
+                                    m3u8 += "#EXT-X-STREAM-INF:BANDWIDTH=97000,CODECS=\"mp4a.40.2\",AUDIO=\"".concat(audioGroupId, "\"\n");
+                                    m3u8 += "master-".concat(audioGroupId, "_").concat(audioTrack.language, ".m3u8;session=").concat(this._sessionId, "\n");
+                                }
+                            }
+                        }
+                        this.produceEvent({
+                            type: 'NOW_PLAYING',
+                            data: {
+                                id: this.currentMetadata.id,
+                                title: this.currentMetadata.title,
+                            }
+                        });
+                        this._sessionState.set("tsLastRequestMaster", Date.now());
+                        return [2 /*return*/, m3u8];
+                }
+            });
+        });
+    };
+    Session.prototype.getAudioGroupsAndLangs = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var currentVod, audioGroupIds, allAudioGroupsAndTheirLanguages;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 1:
+                        currentVod = _a.sent();
+                        if (!currentVod) {
+                            throw new Error('Session not ready');
+                        }
+                        audioGroupIds = currentVod.getAudioGroups();
+                        allAudioGroupsAndTheirLanguages = {};
+                        audioGroupIds.forEach(function (groupId) {
+                            allAudioGroupsAndTheirLanguages[groupId] =
+                                currentVod.getAudioLangsForAudioGroup(groupId);
+                        });
+                        return [2 /*return*/, allAudioGroupsAndTheirLanguages];
+                }
+            });
+        });
+    };
+    Session.prototype.consumeEvent = function () {
+        return this._events.shift();
+    };
+    Session.prototype.produceEvent = function (event) {
+        this._events.push(event);
+    };
+    Session.prototype.hasPlayhead = function () {
+        return !this.disabledPlayhead;
+    };
+    Session.prototype._insertSlate = function (currentVod) {
+        return __awaiter(this, void 0, void 0, function () {
+            var slateVod, sessionState, endValue, lastDiscontinuity;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.slateUri) return [3 /*break*/, 11];
+                        console.error("[".concat(this._sessionId, "]: Will insert slate"));
+                        return [4 /*yield*/, this._loadSlate(currentVod)];
+                    case 1:
+                        slateVod = _a.sent();
+                        debug("[".concat(this._sessionId, "]: slate loaded"));
+                        return [4 /*yield*/, this._sessionState.getValues(["slateCount", "mediaSeq", "discSeq"])];
+                    case 2:
+                        sessionState = _a.sent();
+                        endValue = 0;
+                        lastDiscontinuity = 0;
+                        if (currentVod) {
+                            if (currentVod.sequenceAlwaysContainNewSegments) {
+                                endValue = currentVod.getLastSequenceMediaSequenceValue();
+                            }
+                            else {
+                                endValue = currentVod.getLiveMediaSequencesCount();
+                            }
+                            lastDiscontinuity = currentVod.getLastDiscontinuity();
+                        }
+                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqVideo", 0)];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqAudio", 0)];
+                    case 4:
+                        _a.sent();
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_NEXT_INITIATING)];
+                    case 5:
+                        _a.sent();
+                        return [4 /*yield*/, this._sessionState.setCurrentVod(slateVod)];
+                    case 6:
+                        _a.sent();
+                        return [4 /*yield*/, this._sessionState.set("mediaSeq", sessionState.mediaSeq + endValue)];
+                    case 7:
+                        _a.sent();
+                        return [4 /*yield*/, this._sessionState.set("discSeq", sessionState.discSeq + lastDiscontinuity)];
+                    case 8:
+                        _a.sent();
+                        return [4 /*yield*/, this._sessionState.set("slateCount", sessionState.slateCount + 1)];
+                    case 9:
+                        _a.sent();
+                        return [4 /*yield*/, this._playheadState.set("playheadRef", Date.now())];
+                    case 10:
+                        _a.sent();
+                        cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'slateInserted', channel: this._sessionId });
+                        return [2 /*return*/, slateVod];
+                    case 11: return [2 /*return*/, null];
+                }
+            });
+        });
+    };
+    Session.prototype._tickAsync = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var newVod, sessionState, isLeader, currentVod, vodResponse, _a, nextVodPromise, nextVodStart, _b, loadPromise, hlsOpts, loadStart, _c, _d, _e, _f, _g, _h, _j, _k, err_6, _l, length_1, endMseqValue, lastDiscontinuity, _m, vodPromise, gracePeriod, nextVodStart, _o, loadPromise, hlsOpts, loadStart, _p, _q, _r, _s, _t, _u, _v, diffMs, err_7, startTS, _w, mSeq, currentVod_1, dSeq, mSeqOffset, reloadBehind, segments, playheadState, nextMseq, _x, err_8;
+            var _this = this;
+            return __generator(this, function (_y) {
+                switch (_y.label) {
+                    case 0: return [4 /*yield*/, this._sessionState.getValues(["state", "assetId", "vodMediaSeqVideo", "vodMediaSeqAudio", "mediaSeq", "discSeq", "nextVod"])];
+                    case 1:
+                        sessionState = _y.sent();
+                        return [4 /*yield*/, this._sessionStateStore.isLeader(this._instanceId)];
+                    case 2:
+                        isLeader = _y.sent();
+                        return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 3:
+                        currentVod = _y.sent();
+                        if (!sessionState.state) {
+                            sessionState.state = SessionState.VOD_INIT;
+                        }
+                        _a = sessionState.state;
+                        switch (_a) {
+                            case SessionState.VOD_INIT: return [3 /*break*/, 4];
+                            case SessionState.VOD_INIT_BY_ID: return [3 /*break*/, 4];
+                            case SessionState.VOD_PLAYING: return [3 /*break*/, 25];
+                            case SessionState.VOD_NEXT_INITIATING: return [3 /*break*/, 31];
+                            case SessionState.VOD_NEXT_INIT: return [3 /*break*/, 32];
+                            case SessionState.VOD_RELOAD_INIT: return [3 /*break*/, 58];
+                            case SessionState.VOD_RELOAD_INITIATING: return [3 /*break*/, 78];
+                        }
+                        return [3 /*break*/, 82];
+                    case 4:
+                        _y.trys.push([4, 22, , 25]);
+                        // Needed if store was reset
+                        return [4 /*yield*/, this._sessionStateStore.clearLeaderCache()];
+                    case 5:
+                        // Needed if store was reset
+                        _y.sent();
+                        return [4 /*yield*/, this._sessionStateStore.isLeader(this._instanceId)];
+                    case 6:
+                        isLeader = _y.sent();
+                        nextVodPromise = void 0;
+                        if (sessionState.state === SessionState.VOD_INIT) {
+                            debug("[".concat(this._sessionId, "]: state=VOD_INIT"));
+                            nextVodPromise = this._getNextVod();
+                        }
+                        else if (sessionState.state === SessionState.VOD_INIT_BY_ID) {
+                            debug("[".concat(this._sessionId, "]: state=VOD_INIT_BY_ID ").concat(sessionState.assetId));
+                            nextVodPromise = this._getNextVodById(sessionState.assetId);
+                        }
+                        if (!isLeader) return [3 /*break*/, 18];
+                        nextVodStart = Date.now();
+                        return [4 /*yield*/, nextVodPromise];
+                    case 7:
+                        vodResponse = _y.sent();
+                        _b = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("nextVod", vodResponse)];
+                    case 8:
+                        _b.nextVod = _y.sent();
+                        cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'nextVod', channel: this._sessionId, reqTimeMs: Date.now() - nextVodStart });
+                        loadPromise = void 0;
+                        if (!vodResponse.type) {
+                            debug("[".concat(this._sessionId, "]: got first VOD uri=").concat(vodResponse.uri, ":").concat(vodResponse.offset || 0));
+                            hlsOpts = { sequenceAlwaysContainNewSegments: this.alwaysNewSegments };
+                            newVod = new HLSVod(vodResponse.uri, [], null, vodResponse.offset * 1000, m3u8Header(this._instanceId), hlsOpts);
+                            if (vodResponse.timedMetadata) {
+                                Object.keys(vodResponse.timedMetadata).map(function (k) {
+                                    newVod.addMetadata(k, vodResponse.timedMetadata[k]);
+                                });
+                            }
+                            currentVod = newVod;
+                            loadPromise = currentVod.load();
+                        }
+                        else {
+                            if (vodResponse.type === 'gap') {
+                                loadPromise = new Promise(function (resolve, reject) {
+                                    _this._fillGap(null, vodResponse.desiredDuration)
+                                        .then(function (gapVod) {
+                                        currentVod = gapVod;
+                                        resolve(gapVod);
+                                    }).catch(reject);
+                                });
+                            }
+                        }
+                        loadStart = Date.now();
+                        return [4 /*yield*/, loadPromise];
+                    case 9:
+                        _y.sent();
+                        cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'loadVod', channel: this._sessionId, loadTimeMs: Date.now() - loadStart });
+                        debug("[".concat(this._sessionId, "]: first VOD loaded"));
+                        debug("[".concat(this._sessionId, "]: ").concat(currentVod.getDeltaTimes()));
+                        debug("[".concat(this._sessionId, "]: ").concat(currentVod.getPlayheadPositions()));
+                        //debug(newVod);
+                        _c = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("mediaSeq", 0)];
+                    case 10:
+                        //debug(newVod);
+                        _c.mediaSeq = _y.sent();
+                        _d = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("discSeq", 0)];
+                    case 11:
+                        _d.discSeq = _y.sent();
+                        _e = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqVideo", 0)];
+                    case 12:
+                        _e.vodMediaSeqVideo = _y.sent();
+                        _f = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqAudio", 0)];
+                    case 13:
+                        _f.vodMediaSeqAudio = _y.sent();
+                        return [4 /*yield*/, this._playheadState.set("playheadRef", Date.now())];
+                    case 14:
+                        _y.sent();
+                        this.produceEvent({
+                            type: 'NOW_PLAYING',
+                            data: {
+                                id: this.currentMetadata.id,
+                                title: this.currentMetadata.title,
+                            }
+                        });
+                        _g = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_PLAYING)];
+                    case 15:
+                        _g.state = _y.sent();
+                        _h = sessionState;
+                        return [4 /*yield*/, this._sessionState.setCurrentVod(currentVod, { ttl: currentVod.getDuration() * 1000 })];
+                    case 16:
+                        _h.currentVod = _y.sent();
+                        return [4 /*yield*/, this._sessionState.remove("nextVod")];
+                    case 17:
+                        _y.sent();
+                        return [2 /*return*/];
+                    case 18:
+                        debug("[".concat(this._sessionId, "]: not a leader so will go directly to state VOD_PLAYING"));
+                        _j = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_PLAYING)];
+                    case 19:
+                        _j.state = _y.sent();
+                        _k = sessionState;
+                        return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 20:
+                        _k.currentVod = _y.sent();
+                        return [2 /*return*/];
+                    case 21: return [3 /*break*/, 25];
+                    case 22:
+                        err_6 = _y.sent();
+                        console.error("[".concat(this._sessionId, "]: Failed to init first VOD"));
+                        if (this._assetManager.handleError) {
+                            this._assetManager.handleError(new Error("Failed to init first VOD"), vodResponse);
+                        }
+                        cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'error', on: 'firstvod', channel: this._sessionId, err: err_6, vod: vodResponse });
+                        debug(err_6);
+                        return [4 /*yield*/, this._sessionState.remove("nextVod")];
+                    case 23:
+                        _y.sent();
+                        return [4 /*yield*/, this._insertSlate(currentVod)];
+                    case 24:
+                        currentVod = _y.sent();
+                        if (!currentVod) {
+                            debug("No slate to load");
+                            throw err_6;
+                        }
+                        return [3 /*break*/, 25];
+                    case 25:
+                        if (!isLeader) return [3 /*break*/, 29];
+                        // Handle edge case where store has been reset, but leader has not cleared cache.
+                        if (this.prevVodMediaSeq.video === null) {
+                            this.prevVodMediaSeq.video = sessionState.vodMediaSeqVideo;
+                        }
+                        if (this.prevMediaSeqOffset.video === null) {
+                            this.prevMediaSeqOffset.video = sessionState.mediaSeq;
+                        }
+                        if (!(sessionState.vodMediaSeqVideo < this.prevVodMediaSeq.video)) return [3 /*break*/, 28];
+                        debug("[".concat(this._sessionId, "]: state=VOD_PLAYING, current[").concat(sessionState.vodMediaSeqVideo, "], prev[").concat(this.prevVodMediaSeq.video, "], total[").concat(currentVod.getLiveMediaSequencesCount(), "]"));
+                        return [4 /*yield*/, this._sessionState.clearCurrentVodCache()];
+                    case 26:
+                        _y.sent();
+                        return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 27:
+                        currentVod = _y.sent();
+                        this.prevVodMediaSeq.video = sessionState.vodMediaSeqVideo;
+                        _y.label = 28;
+                    case 28: return [3 /*break*/, 30];
+                    case 29:
+                        // Handle edge case where Leader loaded next vod but Follower remained in state=VOD_PLAYING
+                        if (this.prevMediaSeqOffset.video !== null & sessionState.mediaSeq !== this.prevMediaSeqOffset.video) {
+                            debug("[".concat(this._sessionId, "]: state=VOD_PLAYING, current[").concat(sessionState.vodMediaSeqVideo, "], prev[").concat(this.prevVodMediaSeq.video, "], total[").concat(currentVod.getLiveMediaSequencesCount(), "]"));
+                            debug("[".concat(this._sessionId, "]: mediaSeq offsets -> current[").concat(sessionState.vodMediaSeqVideo, "], prev[").concat(this.prevVodMediaSeq.video, "]"));
+                            // Allow Follower to clear VodCache...
+                            this.isAllowedToClearVodCache = true;
+                        }
+                        _y.label = 30;
+                    case 30:
+                        debug("[".concat(this._sessionId, "]: state=VOD_PLAYING (").concat(sessionState.vodMediaSeqVideo, "_").concat(sessionState.vodMediaSeqAudio, ", ").concat(currentVod.getLiveMediaSequencesCount(), ")"));
+                        return [2 /*return*/];
+                    case 31:
+                        debug("[".concat(this._sessionId, "]: state=VOD_NEXT_INITIATING (").concat(sessionState.vodMediaSeqVideo, "_").concat(sessionState.vodMediaSeqAudio, ", ").concat(currentVod.getLiveMediaSequencesCount(), ")"));
+                        if (!isLeader) {
+                            debug("[".concat(this._sessionId, "]: not the leader so just waiting for the VOD to be initiated"));
+                        }
+                        // Allow Leader|Follower to clear vodCache...
+                        this.isAllowedToClearVodCache = true;
+                        return [2 /*return*/];
+                    case 32:
+                        _y.trys.push([32, 54, , 57]);
+                        debug("[".concat(this._sessionId, "]: state=VOD_NEXT_INIT"));
+                        if (!isLeader) return [3 /*break*/, 49];
+                        if (!!currentVod) return [3 /*break*/, 34];
+                        debug("[".concat(this._sessionId, "]: no VOD to append to, assume first VOD to init"));
+                        _l = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_INIT)];
+                    case 33:
+                        _l.state = _y.sent();
+                        return [2 /*return*/];
+                    case 34:
+                        length_1 = currentVod.getLiveMediaSequencesCount();
+                        endMseqValue = void 0;
+                        if (currentVod.sequenceAlwaysContainNewSegments) {
+                            endMseqValue = currentVod.getLastSequenceMediaSequenceValue();
+                        }
+                        else {
+                            endMseqValue = currentVod.getLiveMediaSequencesCount();
+                        }
+                        lastDiscontinuity = currentVod.getLastDiscontinuity();
+                        _m = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_NEXT_INITIATING)];
+                    case 35:
+                        _m.state = _y.sent();
+                        vodPromise = this._getNextVod();
+                        if (!(length_1 === 1)) return [3 /*break*/, 37];
+                        gracePeriod = (this.averageSegmentDuration / 2);
+                        debug("[".concat(this._sessionId, "]: adding a grace period before calling nextVod: ").concat(gracePeriod, "ms"));
+                        return [4 /*yield*/, timer(gracePeriod)];
+                    case 36:
+                        _y.sent();
+                        _y.label = 37;
+                    case 37:
+                        nextVodStart = Date.now();
+                        return [4 /*yield*/, vodPromise];
+                    case 38:
+                        vodResponse = _y.sent();
+                        _o = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("nextVod", vodResponse)];
+                    case 39:
+                        _o.nextVod = _y.sent();
+                        cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'nextVod', channel: this._sessionId, reqTimeMs: Date.now() - nextVodStart });
+                        loadPromise = void 0;
+                        if (!vodResponse.type) {
+                            debug("[".concat(this._sessionId, "]: got next VOD uri=").concat(vodResponse.uri, ":").concat(vodResponse.offset));
+                            hlsOpts = { sequenceAlwaysContainNewSegments: this.alwaysNewSegments };
+                            newVod = new HLSVod(vodResponse.uri, null, null, vodResponse.offset * 1000, m3u8Header(this._instanceId), hlsOpts);
+                            if (vodResponse.timedMetadata) {
+                                Object.keys(vodResponse.timedMetadata).map(function (k) {
+                                    newVod.addMetadata(k, vodResponse.timedMetadata[k]);
+                                });
+                            }
+                            this.produceEvent({
+                                type: 'NEXT_VOD_SELECTED',
+                                data: {
+                                    id: this.currentMetadata.id,
+                                    uri: vodResponse.uri,
+                                    title: this.currentMetadata.title || '',
+                                }
+                            });
+                            loadPromise = newVod.loadAfter(currentVod);
+                            if (vodResponse.diffMs) {
+                                this.diffCompensation = vodResponse.diffMs;
+                                if (this.diffCompensation) {
+                                    this.timePositionOffset = this.diffCompensation;
+                                    cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'timePositionOffsetUpdated', channel: this._sessionId, offsetMs: this.timePositionOffset });
+                                }
+                                else {
+                                    this.timePositionOffset = 0;
+                                }
+                            }
+                        }
+                        else {
+                            loadPromise = new Promise(function (resolve, reject) {
+                                _this._fillGap(currentVod, vodResponse.desiredDuration)
+                                    .then(function (gapVod) {
+                                    newVod = gapVod;
+                                    resolve(newVod);
+                                }).catch(reject);
+                            });
+                        }
+                        loadStart = Date.now();
+                        return [4 /*yield*/, ChaosMonkey.loadVod(loadPromise)];
+                    case 40:
+                        _y.sent();
+                        cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'loadVod', channel: this._sessionId, loadTimeMs: Date.now() - loadStart });
+                        this.leaderIsSettingNextVod = true;
+                        debug("[".concat(this._sessionId, "]: next VOD loaded (").concat(newVod.getDeltaTimes(), ")"));
+                        debug("[".concat(this._sessionId, "]: ").concat(newVod.getPlayheadPositions()));
+                        currentVod = newVod;
+                        debug("[".concat(this._sessionId, "]: msequences=").concat(currentVod.getLiveMediaSequencesCount()));
+                        _p = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqVideo", 0)];
+                    case 41:
+                        _p.vodMediaSeqVideo = _y.sent();
+                        _q = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqAudio", 0)];
+                    case 42:
+                        _q.vodMediaSeqAudio = _y.sent();
+                        _r = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("mediaSeq", sessionState.mediaSeq + endMseqValue)];
+                    case 43:
+                        _r.mediaSeq = _y.sent();
+                        _s = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("discSeq", sessionState.discSeq + lastDiscontinuity)];
+                    case 44:
+                        _s.discSeq = _y.sent();
+                        debug("[".concat(this._sessionId, "]: new sequence data set in store [").concat(sessionState.mediaSeq, "][").concat(sessionState.discSeq, "]"));
+                        return [4 /*yield*/, this._sessionState.remove("nextVod")];
+                    case 45:
+                        _y.sent();
+                        _t = sessionState;
+                        return [4 /*yield*/, this._sessionState.setCurrentVod(currentVod, { ttl: currentVod.getDuration() * 1000 })];
+                    case 46:
+                        _t.currentVod = _y.sent();
+                        this.leaderIsSettingNextVod = false;
+                        return [4 /*yield*/, this._playheadState.set("playheadRef", Date.now())];
+                    case 47:
+                        _y.sent();
+                        return [4 /*yield*/, this._playheadState.set("diffCompensation", this.diffCompensation)];
+                    case 48:
+                        _y.sent();
+                        debug("[".concat(this._sessionId, "]: sharing durrent vods diffCompensation=").concat(this.diffCompensation));
+                        this.produceEvent({
+                            type: 'NOW_PLAYING',
+                            data: {
+                                id: this.currentMetadata.id,
+                                title: this.currentMetadata.title,
+                            }
+                        });
+                        return [2 /*return*/];
+                    case 49:
+                        debug("[".concat(this._sessionId, "]: not a leader so will go directly to state VOD_NEXT_INITIATING"));
+                        this.waitingForNextVod = true;
+                        _u = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_NEXT_INITIATING)];
+                    case 50:
+                        _u.state = _y.sent();
+                        // Allow Leader|Follower to clear vodCache...
+                        this.isAllowedToClearVodCache = true;
+                        _v = sessionState;
+                        return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 51:
+                        _v.currentVod = _y.sent();
+                        return [4 /*yield*/, this._playheadState.get("diffCompensation")];
+                    case 52:
+                        diffMs = _y.sent();
+                        if (diffMs) {
+                            this.diffCompensation = diffMs;
+                            debug("[".concat(this._sessionId, "]: Setting diffCompensation=").concat(this.diffCompensation));
+                            if (this.diffCompensation) {
+                                this.timePositionOffset = this.diffCompensation;
+                                cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'timePositionOffsetUpdated', channel: this._sessionId, offsetMs: this.timePositionOffset });
+                            }
+                            else {
+                                this.timePositionOffset = 0;
+                            }
+                        }
+                        _y.label = 53;
+                    case 53: return [3 /*break*/, 57];
+                    case 54:
+                        err_7 = _y.sent();
+                        console.error("[".concat(this._sessionId, "]: Failed to init next VOD"));
+                        debug("[".concat(this._sessionId, "]: ").concat(err_7));
+                        if (this._assetManager.handleError) {
+                            this._assetManager.handleError(new Error("Failed to init next VOD"), vodResponse);
+                        }
+                        cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'error', on: 'nextvod', channel: this._sessionId, err: err_7, vod: vodResponse });
+                        return [4 /*yield*/, this._sessionState.remove("nextVod")];
+                    case 55:
+                        _y.sent();
+                        return [4 /*yield*/, this._insertSlate(currentVod)];
+                    case 56:
+                        currentVod = _y.sent();
+                        if (!currentVod) {
+                            debug("No slate to load");
+                            throw err_7;
+                        }
+                        // Allow Leader|Follower to clear vodCache...
+                        this.isAllowedToClearVodCache = true;
+                        return [3 /*break*/, 57];
+                    case 57: return [3 /*break*/, 83];
+                    case 58:
+                        _y.trys.push([58, 76, , 77]);
+                        debug("[".concat(this._sessionId, "]: state=VOD_RELOAD_INIT"));
+                        if (!isLeader) return [3 /*break*/, 73];
+                        startTS = Date.now();
+                        // 1) To tell Follower that, Leader is working on it!
+                        _w = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_RELOAD_INITIATING)];
+                    case 59:
+                        // 1) To tell Follower that, Leader is working on it!
+                        _w.state = _y.sent();
+                        mSeq = this.switchDataForSession.mediaSeq;
+                        return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 60:
+                        currentVod_1 = _y.sent();
+                        if (currentVod_1.sequenceAlwaysContainNewSegments) {
+                            // (!) will need to compensate if using this setting on HLSVod Object.
+                            Object.keys(this.switchDataForSession.transitionSegments).forEach(function (bw) {
+                                var shiftedSeg = _this.switchDataForSession.transitionSegments[bw].shift();
+                                if (shiftedSeg && shiftedSeg.discontinuity) {
+                                    shiftedSeg = _this.switchDataForSession.transitionSegments[bw].shift();
+                                }
+                            });
+                        }
+                        dSeq = this.switchDataForSession.discSeq;
+                        mSeqOffset = this.switchDataForSession.mediaSeqOffset;
+                        reloadBehind = this.switchDataForSession.reloadBehind;
+                        segments = this.switchDataForSession.transitionSegments;
+                        if ([mSeq, dSeq, mSeqOffset, reloadBehind, segments].includes(null)) {
+                            debug("[".concat(this._sessionId, "]: LEADER: Cannot Reload VOD, missing switch-back data"));
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this._sessionState.set("mediaSeq", mSeq)];
+                    case 61:
+                        _y.sent();
+                        return [4 /*yield*/, this._playheadState.set("mediaSeq", mSeq)];
+                    case 62:
+                        _y.sent();
+                        return [4 /*yield*/, this._sessionState.set("discSeq", dSeq)];
+                    case 63:
+                        _y.sent();
+                        debug("[".concat(this._sessionId, "]: Setting current media and discontinuity count -> [").concat(mSeq, "]:[").concat(dSeq, "]"));
+                        // 3) Set new media segments/currentVod, to carry on the continuity from session-live
+                        debug("[".concat(this._sessionId, "]: LEADER: making changes to current VOD. I will also update currentVod in store."));
+                        return [4 /*yield*/, this._playheadState.getValues(["vodMediaSeqVideo"])];
+                    case 64:
+                        playheadState = _y.sent();
+                        nextMseq = playheadState.vodMediaSeqVideo + 1;
+                        if (nextMseq > currentVod_1.getLiveMediaSequencesCount() - 1) {
+                            nextMseq = currentVod_1.getLiveMediaSequencesCount() - 1;
+                        }
+                        // ---------------------------------------------------.
+                        // TODO: Support reloading with audioSegments as well |
+                        // ---------------------------------------------------'
+                        return [4 /*yield*/, currentVod_1.reload(nextMseq, segments, null, reloadBehind)];
+                    case 65:
+                        // ---------------------------------------------------.
+                        // TODO: Support reloading with audioSegments as well |
+                        // ---------------------------------------------------'
+                        _y.sent();
+                        return [4 /*yield*/, this._sessionState.setCurrentVod(currentVod_1, { ttl: currentVod_1.getDuration() * 1000 })];
+                    case 66:
+                        _y.sent();
+                        return [4 /*yield*/, this._sessionState.set("vodReloaded", 1)];
+                    case 67:
+                        _y.sent();
+                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqVideo", 0)];
+                    case 68:
+                        _y.sent();
+                        return [4 /*yield*/, this._sessionState.set("vodMediaSeqAudio", 0)];
+                    case 69:
+                        _y.sent();
+                        return [4 /*yield*/, this._playheadState.set("vodMediaSeqVideo", 0)];
+                    case 70:
+                        _y.sent();
+                        return [4 /*yield*/, this._playheadState.set("vodMediaSeqAudio", 0)];
+                    case 71:
+                        _y.sent();
+                        return [4 /*yield*/, this._playheadState.set("playheadRef", Date.now())];
+                    case 72:
+                        _y.sent();
+                        // 4) Log to debug and cloudwatch
+                        debug("[".concat(this._sessionId, "]: LEADER: Set new Reloaded VOD and vodMediaSeq counts in store."));
+                        debug("[".concat(this._sessionId, "]: next VOD Reloaded (").concat(currentVod_1.getDeltaTimes(), ")"));
+                        debug("[".concat(this._sessionId, "]: ").concat(currentVod_1.getPlayheadPositions()));
+                        debug("[".concat(this._sessionId, "]: msequences=").concat(currentVod_1.getLiveMediaSequencesCount()));
+                        cloudWatchLog(!this.cloudWatchLogging, "engine-session", { event: "switchback", channel: this._sessionId, reqTimeMs: Date.now() - startTS });
+                        return [2 /*return*/];
+                    case 73:
+                        debug("[".concat(this._sessionId, "]: not a leader so will go directly to state VOD_RELOAD_INITIATING"));
+                        _x = sessionState;
+                        return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_RELOAD_INITIATING)];
+                    case 74:
+                        _x.state = _y.sent();
+                        _y.label = 75;
+                    case 75: return [3 /*break*/, 77];
+                    case 76:
+                        err_8 = _y.sent();
+                        debug("Failed to init reload vod");
+                        throw err_8;
+                    case 77: return [3 /*break*/, 83];
+                    case 78:
+                        debug("[".concat(this._sessionId, "]: state=VOD_RELOAD_INITIATING (").concat(sessionState.vodMediaSeqVideo, "_").concat(sessionState.vodMediaSeqAudio, ", ").concat(currentVod.getLiveMediaSequencesCount(), ")"));
+                        if (!!isLeader) return [3 /*break*/, 81];
+                        debug("[".concat(this._sessionId, "]: not the leader so just waiting for the VOD to be reloaded"));
+                        if (!(sessionState.vodMediaSeqVideo === 0 || this.waitingForNextVod)) return [3 /*break*/, 80];
+                        debug("[".concat(this._sessionId, "]: First mediasequence in VOD and I am not the leader so invalidate current VOD cache and fetch the new one from the leader"));
+                        return [4 /*yield*/, this._sessionState.clearCurrentVodCache()];
+                    case 79:
+                        _y.sent();
+                        _y.label = 80;
+                    case 80:
+                        this.waitingForNextVod = true;
+                        _y.label = 81;
+                    case 81:
+                        // Allow Leader|Follower to clear vodCache...
+                        this.isAllowedToClearVodCache = true;
+                        return [2 /*return*/];
+                    case 82: throw new Error("Invalid state: " + sessionState.state);
+                    case 83: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Session.prototype._getNextVod = function () {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var nextVodPromise;
+            nextVodPromise = _this._assetManager.getNextVod({
+                sessionId: _this._sessionId,
+                category: _this._category,
+                playlistId: _this._sessionId
+            });
+            nextVodPromise.then(function (nextVod) {
+                if (nextVod && nextVod.uri) {
+                    _this.currentMetadata = {
+                        id: nextVod.id,
+                        title: nextVod.title || '',
+                    };
+                    resolve(nextVod);
+                }
+                else if (nextVod && nextVod.type === 'gap') {
+                    _this.currentMetadata = {
+                        id: 'GAP',
+                        title: 'GAP of ' + Math.floor(nextVod.desiredDuration) + ' sec',
+                    };
+                    resolve(nextVod);
+                }
+                else {
+                    console.error("Invalid VOD:", nextVod);
+                    reject("Invalid VOD from asset manager");
+                }
+            })
+                .catch(reject);
+        });
+    };
+    Session.prototype._loadSlate = function (afterVod, reps) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            try {
+                var slateVod_1 = new HLSRepeatVod(_this.slateUri, reps || _this.slateRepetitions);
+                var hlsVod_1;
+                slateVod_1.load()
+                    .then(function () {
+                    var hlsOpts = { sequenceAlwaysContainNewSegments: _this.alwaysNewSegments };
+                    hlsVod_1 = new HLSVod(_this.slateUri, null, null, null, m3u8Header(_this._instanceId), hlsOpts);
+                    var timestamp = Date.now();
+                    hlsVod_1.addMetadata('id', "slate-".concat(timestamp));
+                    hlsVod_1.addMetadata('start-date', new Date(timestamp).toISOString());
+                    hlsVod_1.addMetadata('planned-duration', ((reps || _this.slateRepetitions) * _this.slateDuration) / 1000);
+                    var slateMediaManifestLoader = function (bw) {
+                        var mediaManifestStream = new Readable();
+                        mediaManifestStream.push(slateVod_1.getMediaManifest(bw));
+                        mediaManifestStream.push(null);
+                        return mediaManifestStream;
+                    };
+                    if (afterVod) {
+                        return hlsVod_1.loadAfter(afterVod, null, slateMediaManifestLoader);
+                    }
+                    else {
+                        return hlsVod_1.load(null, slateMediaManifestLoader);
+                    }
+                })
+                    .then(function () {
+                    resolve(hlsVod_1);
+                })
+                    .catch(function (err) {
+                    debug(err);
+                    reject(err);
+                });
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    };
+    Session.prototype._truncateSlate = function (afterVod, requestedDuration, vodUri) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var nexVodUri = null;
+            try {
+                if (vodUri) {
+                    nexVodUri = vodUri;
+                }
+                else {
+                    nexVodUri = _this.slateUri;
+                }
+                var slateVod_2 = new HLSTruncateVod(nexVodUri, requestedDuration);
+                var hlsVod_2;
+                slateVod_2.load()
+                    .then(function () {
+                    var hlsOpts = { sequenceAlwaysContainNewSegments: _this.alwaysNewSegments };
+                    hlsVod_2 = new HLSVod(nexVodUri, null, null, null, m3u8Header(_this._instanceId), hlsOpts);
+                    var timestamp = Date.now();
+                    hlsVod_2.addMetadata('id', "slate-".concat(timestamp));
+                    hlsVod_2.addMetadata('start-date', new Date(timestamp).toISOString());
+                    hlsVod_2.addMetadata('planned-duration', requestedDuration);
+                    var slateMediaManifestLoader = function (bw) {
+                        var mediaManifestStream = new Readable();
+                        mediaManifestStream.push(slateVod_2.getMediaManifest(bw));
+                        mediaManifestStream.push(null);
+                        return mediaManifestStream;
+                    };
+                    if (afterVod) {
+                        return hlsVod_2.loadAfter(afterVod, null, slateMediaManifestLoader);
+                    }
+                    else {
+                        return hlsVod_2.load(null, slateMediaManifestLoader);
+                    }
+                })
+                    .then(function () {
+                    resolve(hlsVod_2);
+                })
+                    .catch(function (err) {
+                    debug(err);
+                    reject(err);
+                });
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    };
+    Session.prototype._fillGap = function (afterVod, desiredDuration) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            var loadSlatePromise;
+            var durationMs;
+            if (desiredDuration > _this.slateDuration) {
+                var reps = Math.floor(desiredDuration / _this.slateDuration);
+                debug("[".concat(_this._sessionId, "]: Trying to fill a gap of ").concat(desiredDuration, " milliseconds (").concat(reps, " repetitions)"));
+                loadSlatePromise = _this._loadSlate(afterVod, reps);
+                durationMs = (reps || _this.slateRepetitions) * _this.slateDuration;
+            }
+            else {
+                debug("[".concat(_this._sessionId, "]: Trying to fill a gap of ").concat(desiredDuration, " milliseconds by truncating filler slate (").concat(_this.slateDuration, ")"));
+                loadSlatePromise = _this._truncateSlate(afterVod, desiredDuration / 1000);
+                durationMs = desiredDuration;
+            }
+            loadSlatePromise.then(function (hlsVod) {
+                cloudWatchLog(!_this.cloudWatchLogging, 'engine-session', { event: 'filler', channel: _this._sessionId, durationMs: durationMs });
+                resolve(hlsVod);
+            }).catch(reject);
+        });
+    };
+    Session.prototype._getNextVodById = function (id) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this._assetManager.getNextVodById(_this._sessionId, id)
+                .then(function (nextVod) {
+                //debug(nextVod);
+                _this.currentMetadata = {
+                    id: nextVod.id,
+                    title: nextVod.title || '',
+                };
+                resolve(nextVod);
+            })
+                .catch(reject);
+        });
+    };
+    Session.prototype._getFirstDuration = function (manifest) {
+        return new Promise(function (resolve, reject) {
+            try {
+                var parser = m3u8.createStream();
+                var manifestStream = new Readable();
+                manifestStream.push(manifest);
+                manifestStream.push(null);
+                manifestStream.pipe(parser);
+                parser.on('m3u', function (m3u) {
+                    if (m3u.items.PlaylistItem[0]) {
+                        var firstDuration = m3u.items.PlaylistItem[0].get("duration");
+                        resolve(firstDuration);
+                    }
+                    else {
+                        console.error("Empty media playlist");
+                        console.error(manifest);
+                        reject('Empty media playlist!');
+                    }
+                });
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    };
+    Session.prototype._getCurrentDeltaTime = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var sessionState, currentVod, deltaTimes;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._sessionState.getValues(["vodMediaSeqVideo"])];
+                    case 1:
+                        sessionState = _a.sent();
+                        return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 2:
+                        currentVod = _a.sent();
+                        deltaTimes = currentVod.getDeltaTimes();
+                        debug("[".concat(this._sessionId, "]: Current delta time (").concat(sessionState.vodMediaSeqVideo, "): ").concat(deltaTimes[sessionState.vodMediaSeqVideo]));
+                        if (deltaTimes[sessionState.vodMediaSeqVideo]) {
+                            return [2 /*return*/, deltaTimes[sessionState.vodMediaSeqVideo]];
+                        }
+                        return [2 /*return*/, 0];
+                }
+            });
+        });
+    };
+    Session.prototype._getCurrentPlayheadPosition = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var sessionState, currentVod, playheadPositions;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this._sessionState.getValues(["vodMediaSeqVideo"])];
+                    case 1:
+                        sessionState = _a.sent();
+                        return [4 /*yield*/, this._sessionState.getCurrentVod()];
+                    case 2:
+                        currentVod = _a.sent();
+                        playheadPositions = currentVod.getPlayheadPositions();
+                        debug("[".concat(this._sessionId, "]: Current playhead position (").concat(sessionState.vodMediaSeqVideo, "): ").concat(playheadPositions[sessionState.vodMediaSeqVideo]));
+                        return [2 /*return*/, playheadPositions[sessionState.vodMediaSeqVideo]];
+                }
+            });
+        });
+    };
+    Session.prototype._getLastDuration = function (manifest) {
+        return new Promise(function (resolve, reject) {
+            try {
+                var parser = m3u8.createStream();
+                var manifestStream = new Readable();
+                manifestStream.push(manifest);
+                manifestStream.push(null);
+                manifestStream.pipe(parser);
+                parser.on('m3u', function (m3u) {
+                    if (m3u.items.PlaylistItem.length > 0) {
+                        var endIdx = m3u.items.PlaylistItem.length - 1;
+                        var bottomDuration = m3u.items.PlaylistItem[endIdx].get("duration");
+                        resolve(bottomDuration);
+                    }
+                    else {
+                        console.error("Empty media playlist");
+                        console.error(manifest);
+                        reject('Empty media playlist!');
+                    }
+                });
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    };
+    Session.prototype._getPlayheadDiffCompesationValue = function (diffMs, thresholdMs) {
+        var compensationSec = 0;
+        if (diffMs > thresholdMs) {
+            compensationSec = (diffMs / 1000) - (thresholdMs / 1000);
+            debug("[".concat(this._sessionId, "]: Playhead stepping msequences too early. Need to wait longer. adding ").concat(compensationSec, "s"));
+            return compensationSec;
+        }
+        else if (diffMs < -thresholdMs) {
+            compensationSec = (diffMs / 1000) + (thresholdMs / 1000);
+            debug("[".concat(this._sessionId, "]: Playhead stepping msequences too LATE. Need to fast-forward. adding ").concat(compensationSec, "s"));
+            return compensationSec;
+        }
+        else {
+            return compensationSec;
+        }
+    };
+    return Session;
+}());
+module.exports = Session;