eyevinn-channel-engine 5.0.4 → 5.0.6

package/dist/engine/session.js

@@ -1012,47 +1012,42 @@ var Session = /** @class */ (function () {
     };
     Session.prototype.incrementAsync = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var isLeader, sessionState, playheadState, currentVod, _a, isOldVod, nextState, leaderAction, leaderState, _b, m3u8_1, _c, playheadPosVideoMs, playheadAudio, playheadSubtitle, audioSeqLastIdx, sessionStateObj, _d, playheadPosVideo, _e, subtitleSeqLastIdx, sessionStateObj, _f, newSessionState, updatedValues, updatedPlayhead, mediaSequenceValue, audioInfo, mediaSequenceValueAudio, subsInfo, mediaSequenceValueSubtitle, diffMs, m3u8;
-            return __generator(this, function (_g) {
-                switch (_g.label) {
+            var _a, tickSessionState, isLeader, tickCurrentVod, sessionState, currentVod, playheadState, _b, newSessionState, isOldVod, nextState, leaderAction, leaderState, _c, m3u8_1, playheadPosVideoMs, playheadAudio, playheadSubtitle, audioSeqLastIdx, subtitleSeqLastIdx, playheadData, _d, updatedValues, updatedPlayhead, mediaSequenceValue, audioInfo, mediaSequenceValueAudio, subsInfo, mediaSequenceValueSubtitle, diffMs, m3u8;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0: return [4 /*yield*/, this._tickAsync()];
                     case 1:
-                        _g.sent();
-                        return [4 /*yield*/, this._sessionStateStore.isLeader(this._instanceId)];
-                    case 2:
-                        isLeader = _g.sent();
-                        return [4 /*yield*/, this._sessionState.getValues(["state", "mediaSeq", "mediaSeqAudio", "mediaSeqSubtitle", "discSeq", "discSeqAudio", "discSeqSubtitle", "vodMediaSeqVideo", "vodMediaSeqAudio", "vodMediaSeqSubtitle"])];
-                    case 3:
-                        sessionState = _g.sent();
+                        _e.sent();
+                        _a = this._lastTickState, tickSessionState = _a.sessionState, isLeader = _a.isLeader, tickCurrentVod = _a.currentVod;
+                        sessionState = tickSessionState;
+                        currentVod = tickCurrentVod;
                         return [4 /*yield*/, this._playheadState.getValues(["mediaSeq", "mediaSeqAudio", "mediaSeqSubtitle", "vodMediaSeqVideo", "vodMediaSeqAudio", "vodMediaSubtitle", "playheadRef"])];
-                    case 4:
-                        playheadState = _g.sent();
-                        return [4 /*yield*/, this._sessionState.getCurrentVod()];
-                    case 5:
-                        currentVod = _g.sent();
+                    case 2:
+                        playheadState = _e.sent();
                         if (!(!currentVod ||
                             sessionState.vodMediaSeqVideo === null ||
                             sessionState.vodMediaSeqAudio === null ||
                             sessionState.vodMediaSeqSubtitle === null ||
                             sessionState.state === null ||
                             sessionState.mediaSeq === null ||
-                            sessionState.discSeq === null)) return [3 /*break*/, 9];
+                            sessionState.discSeq === null)) return [3 /*break*/, 6];
                         debug("[".concat(this._sessionId, "]: Session is not ready yet"));
                         debug(sessionState);
                         return [4 /*yield*/, this._sessionState.clearCurrentVodCache()];
-                    case 6:
-                        _g.sent();
-                        if (!isLeader) return [3 /*break*/, 8];
+                    case 3:
+                        _e.sent();
+                        if (!isLeader) return [3 /*break*/, 5];
                         debug("[".concat(this._sessionId, "]: I am the leader, trying to initiate the session"));
-                        _a = sessionState;
+                        _b = sessionState;
                         return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_INIT)];
-                    case 7:
-                        _a.state = _g.sent();
-                        _g.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];
+                    case 4:
+                        _b.state = _e.sent();
+                        _e.label = 5;
+                    case 5: return [2 /*return*/, null];
+                    case 6:
+                        newSessionState = {};
+                        if (!(sessionState.state === SessionState.VOD_NEXT_INITIATING || sessionState.state === SessionState.VOD_RELOAD_INITIATING)) return [3 /*break*/, 11];
+                        if (!isLeader) return [3 /*break*/, 8];
                         isOldVod = this._isOldVod(playheadState.playheadRef, currentVod.getDuration());
                         nextState = SessionState.VOD_PLAYING;
                         if (isOldVod) {
@@ -1061,16 +1056,16 @@ var Session = /** @class */ (function () {
                         leaderAction = sessionState.state === SessionState.VOD_NEXT_INITIATING ? "initiated" : "reloaded";
                         leaderState = nextState === SessionState.VOD_NEXT_INIT ? "VOD_NEXT_INIT" : "VOD_PLAYING";
                         debug("[".concat(this._sessionId, "]: I am the leader and have just ").concat(leaderAction, " next VOD, let's move to  ").concat(leaderState));
-                        _b = sessionState;
+                        _c = sessionState;
                         return [4 /*yield*/, this._sessionState.set("state", nextState)];
-                    case 10:
-                        _b.state = _g.sent();
-                        return [3 /*break*/, 13];
-                    case 11:
+                    case 7:
+                        _c.state = _e.sent();
+                        return [3 /*break*/, 10];
+                    case 8:
                         debug("[".concat(this._sessionId, "]: Return the last generated m3u8 to give the leader some time"));
                         return [4 /*yield*/, this._playheadState.getLastM3u8()];
-                    case 12:
-                        m3u8_1 = _g.sent();
+                    case 9:
+                        m3u8_1 = _e.sent();
                         if (m3u8_1) {
                             return [2 /*return*/, m3u8_1];
                         }
@@ -1078,63 +1073,51 @@ var Session = /** @class */ (function () {
                             debug("[".concat(this._sessionId, "]: We don't have any previously generated m3u8"));
                         }
                         this.isAllowedToClearVodCache = true;
-                        _g.label = 13;
-                    case 13: return [3 /*break*/, 27];
-                    case 14:
-                        _c = sessionState;
-                        return [4 /*yield*/, this._sessionState.increment("vodMediaSeqVideo", 1)];
-                    case 15:
-                        _c.vodMediaSeqVideo = _g.sent();
+                        _e.label = 10;
+                    case 10: return [3 /*break*/, 17];
+                    case 11:
+                        // Compute increments locally instead of individual Redis round-trips
+                        if (isLeader) {
+                            debug("[".concat(this._sessionId, "]: I am incrementing key vodMediaSeqVideo with 1"));
+                            sessionState.vodMediaSeqVideo += 1;
+                        }
                         playheadPosVideoMs = void 0;
                         playheadAudio = void 0;
                         playheadSubtitle = void 0;
                         return [4 /*yield*/, this._getCurrentPlayheadPosition()];
-                    case 16:
-                        playheadPosVideoMs = (_g.sent()) * 1000;
-                        if (!this.use_demuxed_audio) return [3 /*break*/, 20];
+                    case 12:
+                        playheadPosVideoMs = (_e.sent()) * 1000;
+                        if (!this.use_demuxed_audio) return [3 /*break*/, 14];
                         audioSeqLastIdx = currentVod.getLiveMediaSequencesCount("audio") - 1;
-                        return [4 /*yield*/, this._sessionState.getValues(["vodMediaSeqAudio"])];
-                    case 17:
-                        sessionStateObj = _g.sent();
-                        return [4 /*yield*/, this._determineExtraMediaIncrement("audio", playheadPosVideoMs, audioSeqLastIdx, sessionStateObj.vodMediaSeqAudio, this._getAudioPlayheadPosition.bind(this))];
-                    case 18:
-                        playheadAudio = _g.sent();
-                        // Perform the Increment
+                        return [4 /*yield*/, this._determineExtraMediaIncrement("audio", playheadPosVideoMs, audioSeqLastIdx, sessionState.vodMediaSeqAudio, this._getAudioPlayheadPosition.bind(this))];
+                    case 13:
+                        playheadAudio = _e.sent();
                         debug("[".concat(this._sessionId, "]: Will increment audio with ").concat(playheadAudio.increment));
-                        _d = sessionState;
-                        return [4 /*yield*/, this._sessionState.increment("vodMediaSeqAudio", playheadAudio.increment)];
-                    case 19:
-                        _d.vodMediaSeqAudio = _g.sent();
-                        _g.label = 20;
-                    case 20:
-                        if (!this.use_vtt_subtitles) return [3 /*break*/, 26];
-                        _e = playheadPosVideo;
-                        if (_e) return [3 /*break*/, 22];
-                        return [4 /*yield*/, this._getCurrentPlayheadPosition()];
-                    case 21:
-                        _e = (_g.sent()) * 1000;
-                        _g.label = 22;
-                    case 22:
-                        playheadPosVideo = _e;
+                        if (isLeader) {
+                            debug("[".concat(this._sessionId, "]: I am incrementing key vodMediaSeqAudio with ").concat(playheadAudio.increment));
+                            sessionState.vodMediaSeqAudio += (playheadAudio.increment === 0 ? 0 : playheadAudio.increment || 1);
+                        }
+                        _e.label = 14;
+                    case 14:
+                        if (!this.use_vtt_subtitles) return [3 /*break*/, 16];
                         subtitleSeqLastIdx = currentVod.getLiveMediaSequencesCount("subtitle") - 1;
-                        return [4 /*yield*/, this._sessionState.getValues(["vodMediaSeqSubtitle"])];
-                    case 23:
-                        sessionStateObj = _g.sent();
-                        return [4 /*yield*/, this._determineExtraMediaIncrement("subtitle", playheadPosVideoMs, subtitleSeqLastIdx, sessionStateObj.vodMediaSeqSubtitle, this._getSubtitlePlayheadPosition.bind(this))];
-                    case 24:
-                        playheadSubtitle = _g.sent();
-                        // Perform the Increment
+                        return [4 /*yield*/, this._determineExtraMediaIncrement("subtitle", playheadPosVideoMs, subtitleSeqLastIdx, sessionState.vodMediaSeqSubtitle, this._getSubtitlePlayheadPosition.bind(this))];
+                    case 15:
+                        playheadSubtitle = _e.sent();
                         debug("[".concat(this._sessionId, "]: Will increment subtitle with ").concat(playheadSubtitle.increment));
-                        _f = sessionState;
-                        return [4 /*yield*/, this._sessionState.increment("vodMediaSeqSubtitle", playheadSubtitle.increment)];
-                    case 25:
-                        _f.vodMediaSeqSubtitle = _g.sent();
-                        _g.label = 26;
-                    case 26:
+                        if (isLeader) {
+                            debug("[".concat(this._sessionId, "]: I am incrementing key vodMediaSeqSubtitle with ").concat(playheadSubtitle.increment));
+                            sessionState.vodMediaSeqSubtitle += (playheadSubtitle.increment === 0 ? 0 : playheadSubtitle.increment || 1);
+                        }
+                        _e.label = 16;
+                    case 16:
                         this._logCurrentPlayheadPositions(playheadPosVideoMs, playheadAudio, playheadSubtitle);
-                        _g.label = 27;
-                    case 27:
-                        newSessionState = {};
+                        // Include locally-computed increments in the batch write
+                        newSessionState.vodMediaSeqVideo = sessionState.vodMediaSeqVideo;
+                        newSessionState.vodMediaSeqAudio = sessionState.vodMediaSeqAudio;
+                        newSessionState.vodMediaSeqSubtitle = sessionState.vodMediaSeqSubtitle;
+                        _e.label = 17;
+                    case 17:
                         if (sessionState.vodMediaSeqVideo >= currentVod.getLiveMediaSequencesCount() - 1) {
                             newSessionState.vodMediaSeqVideo = currentVod.getLiveMediaSequencesCount() - 1;
                             newSessionState.state = SessionState.VOD_NEXT_INIT;
@@ -1149,23 +1132,24 @@ var Session = /** @class */ (function () {
                             newSessionState.state = SessionState.VOD_RELOAD_INIT;
                             this.isSwitchingBackToV2L = false;
                         }
-                        return [4 /*yield*/, this._sessionState.setValues(newSessionState)];
-                    case 28:
-                        updatedValues = _g.sent();
-                        sessionState = __assign(__assign({}, sessionState), updatedValues);
                         if (isLeader) {
                             debug("[".concat(this._sessionId, "]: I am the leader, updating PlayheadState values"));
                         }
-                        return [4 /*yield*/, this._playheadState.setValues({
-                                "mediaSeq": sessionState.mediaSeq,
-                                "mediaSeqAudio": sessionState.mediaSeqAudio,
-                                "mediaSeqSubtitle": sessionState.mediaSeqSubtitle,
-                                "vodMediaSeqVideo": sessionState.vodMediaSeqVideo,
-                                "vodMediaSeqAudio": sessionState.vodMediaSeqAudio,
-                                "vodMediaSeqSubtitle": sessionState.vodMediaSeqSubtitle
-                            }, isLeader)];
-                    case 29:
-                        updatedPlayhead = _g.sent();
+                        playheadData = {
+                            "mediaSeq": sessionState.mediaSeq,
+                            "mediaSeqAudio": sessionState.mediaSeqAudio,
+                            "mediaSeqSubtitle": sessionState.mediaSeqSubtitle,
+                            "vodMediaSeqVideo": sessionState.vodMediaSeqVideo,
+                            "vodMediaSeqAudio": sessionState.vodMediaSeqAudio,
+                            "vodMediaSeqSubtitle": sessionState.vodMediaSeqSubtitle
+                        };
+                        return [4 /*yield*/, Promise.all([
+                                this._sessionState.setValues(newSessionState),
+                                this._playheadState.setValues(playheadData, isLeader)
+                            ])];
+                    case 18:
+                        _d = _e.sent(), updatedValues = _d[0], updatedPlayhead = _d[1];
+                        sessionState = __assign(__assign({}, sessionState), updatedValues);
                         playheadState = __assign(__assign({}, playheadState), updatedPlayhead);
                         if (currentVod.sequenceAlwaysContainNewSegments) {
                             mediaSequenceValue = currentVod.mediaSequenceValues[playheadState.vodMediaSeqVideo];
@@ -1182,23 +1166,23 @@ var Session = /** @class */ (function () {
                             debug("[".concat(this._sessionId, "]: Session can now serve mseq[V]={").concat(playheadState.mediaSeq + mediaSequenceValue, "}") + audioInfo + subsInfo);
                         }
                         debug("[".concat(this._sessionId, "]: INCREMENT (mseq=").concat(playheadState.mediaSeq + playheadState.vodMediaSeqVideo, ") vodMediaSeq=(").concat(playheadState.vodMediaSeqVideo, "_").concat(playheadState.vodMediaSeqAudio).concat(this.use_vtt_subtitles ? "_".concat(playheadState.vodMediaSeqSubtitle) : "", " of ").concat(currentVod.getLiveMediaSequencesCount(), "_").concat(currentVod.getLiveMediaSequencesCount("audio")).concat(this.use_vtt_subtitles ? "_".concat(currentVod.getLiveMediaSequencesCount("subtitle"), ")") : ")"));
-                        if (!(playheadState.vodMediaSeqVideo < 2 || playheadState.mediaSeq !== this.prevMediaSeqOffset.video)) return [3 /*break*/, 34];
+                        if (!(playheadState.vodMediaSeqVideo < 2 || playheadState.mediaSeq !== this.prevMediaSeqOffset.video)) return [3 /*break*/, 23];
                         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*/, 33];
+                        if (!(!isLeader && this.isAllowedToClearVodCache)) return [3 /*break*/, 22];
                         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 30:
-                        _g.sent();
+                    case 19:
+                        _e.sent();
                         return [4 /*yield*/, this._sessionState.getCurrentVod()];
-                    case 31:
-                        currentVod = _g.sent();
+                    case 20:
+                        currentVod = _e.sent();
                         return [4 /*yield*/, this._playheadState.get("diffCompensation")];
-                    case 32:
-                        diffMs = _g.sent();
+                    case 21:
+                        diffMs = _e.sent();
                         if (diffMs) {
                             this.diffCompensation = diffMs;
                             debug("[".concat(this._sessionId, "]: Setting diffCompensation->").concat(this.diffCompensation));
@@ -1211,12 +1195,12 @@ var Session = /** @class */ (function () {
                             }
                         }
                         this.isAllowedToClearVodCache = false;
-                        _g.label = 33;
-                    case 33: return [3 /*break*/, 35];
-                    case 34:
+                        _e.label = 22;
+                    case 22: return [3 /*break*/, 24];
+                    case 23:
                         this.isAllowedToClearVodCache = true;
-                        _g.label = 35;
-                    case 35:
+                        _e.label = 24;
+                    case 24:
                         // Update Value for Previous Sequence
                         this.prevVodMediaSeq.video = playheadState.vodMediaSeqVideo;
                         this.prevMediaSeqOffset.video = playheadState.mediaSeq;
@@ -1230,8 +1214,8 @@ var Session = /** @class */ (function () {
                         }
                         m3u8 = currentVod.getLiveMediaSequences(playheadState.mediaSeq, 180000, playheadState.vodMediaSeqVideo, sessionState.discSeq);
                         return [4 /*yield*/, this._playheadState.setLastM3u8(m3u8)];
-                    case 36:
-                        _g.sent();
+                    case 25:
+                        _e.sent();
                         return [2 /*return*/, m3u8];
                 }
             });
@@ -1702,26 +1686,29 @@ var Session = /** @class */ (function () {
                         if (!sessionState.state) {
                             sessionState.state = SessionState.VOD_INIT;
                         }
+                        _u.label = 4;
+                    case 4:
+                        _u.trys.push([4, , 106, 107]);
                         _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*/, 29];
-                            case SessionState.VOD_NEXT_INITIATING: return [3 /*break*/, 35];
-                            case SessionState.VOD_NEXT_INIT: return [3 /*break*/, 36];
-                            case SessionState.VOD_RELOAD_INIT: return [3 /*break*/, 67];
-                            case SessionState.VOD_RELOAD_INITIATING: return [3 /*break*/, 96];
-                        }
-                        return [3 /*break*/, 100];
-                    case 4:
-                        _u.trys.push([4, 26, , 29]);
+                            case SessionState.VOD_INIT: return [3 /*break*/, 5];
+                            case SessionState.VOD_INIT_BY_ID: return [3 /*break*/, 5];
+                            case SessionState.VOD_PLAYING: return [3 /*break*/, 31];
+                            case SessionState.VOD_NEXT_INITIATING: return [3 /*break*/, 37];
+                            case SessionState.VOD_NEXT_INIT: return [3 /*break*/, 38];
+                            case SessionState.VOD_RELOAD_INIT: return [3 /*break*/, 70];
+                            case SessionState.VOD_RELOAD_INITIATING: return [3 /*break*/, 100];
+                        }
+                        return [3 /*break*/, 104];
+                    case 5:
+                        _u.trys.push([5, 27, , 31]);
                         // Needed if store was reset
                         return [4 /*yield*/, this._sessionStateStore.clearLeaderCache()];
-                    case 5:
+                    case 6:
                         // Needed if store was reset
                         _u.sent();
                         return [4 /*yield*/, this._sessionStateStore.isLeader(this._instanceId)];
-                    case 6:
+                    case 7:
                         isLeader = _u.sent();
                         nextVodPromise = void 0;
                         if (sessionState.state === SessionState.VOD_INIT) {
@@ -1732,18 +1719,18 @@ var Session = /** @class */ (function () {
                             debug("[".concat(this._sessionId, "]: state=VOD_INIT_BY_ID ").concat(sessionState.assetId));
                             nextVodPromise = this._getNextVodById(sessionState.assetId);
                         }
-                        if (!isLeader) return [3 /*break*/, 22];
+                        if (!isLeader) return [3 /*break*/, 23];
                         nextVodStart = Date.now();
                         return [4 /*yield*/, nextVodPromise];
-                    case 7:
+                    case 8:
                         vodResponse = _u.sent();
                         _b = sessionState;
                         return [4 /*yield*/, this._sessionState.set("nextVod", vodResponse)];
-                    case 8:
+                    case 9:
                         _b.nextVod = _u.sent();
                         cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'nextVod', channel: this._sessionId, reqTimeMs: Date.now() - nextVodStart });
                         loadPromise = void 0;
-                        if (!!vodResponse.type) return [3 /*break*/, 15];
+                        if (!!vodResponse.type) return [3 /*break*/, 16];
                         debug("[".concat(this._sessionId, "]: got first VOD uri=").concat(vodResponse.uri, ":").concat(vodResponse.offset || 0));
                         hlsOpts = {
                             sequenceAlwaysContainNewSegments: this.alwaysNewSegments,
@@ -1763,40 +1750,40 @@ var Session = /** @class */ (function () {
                             });
                         }
                         currentVod = newVod;
-                        if (!vodResponse.desiredDuration) return [3 /*break*/, 13];
-                        _u.label = 9;
-                    case 9:
-                        _u.trys.push([9, 11, , 12]);
-                        return [4 /*yield*/, this._truncateVod(vodResponse)];
+                        if (!vodResponse.desiredDuration) return [3 /*break*/, 14];
+                        _u.label = 10;
                     case 10:
+                        _u.trys.push([10, 12, , 13]);
+                        return [4 /*yield*/, this._truncateVod(vodResponse)];
+                    case 11:
                         _c = _u.sent(), mediaManifestLoader = _c.mediaManifestLoader, audioManifestLoader = _c.audioManifestLoader, subtitleManifestLoader = _c.subtitleManifestLoader;
                         loadPromise = currentVod.load(null, mediaManifestLoader, audioManifestLoader, subtitleManifestLoader);
-                        return [3 /*break*/, 12];
-                    case 11:
+                        return [3 /*break*/, 13];
+                    case 12:
                         e_1 = _u.sent();
                         console.error("[".concat(this._sessionId, "]: Failed to truncate VOD: ").concat(e_1));
                         loadPromise = currentVod.load();
-                        return [3 /*break*/, 12];
-                    case 12: return [3 /*break*/, 14];
-                    case 13:
+                        return [3 /*break*/, 13];
+                    case 13: return [3 /*break*/, 15];
+                    case 14:
                         loadPromise = currentVod.load();
-                        _u.label = 14;
-                    case 14: return [3 /*break*/, 16];
-                    case 15:
+                        _u.label = 15;
+                    case 15: return [3 /*break*/, 17];
+                    case 16:
                         if (vodResponse.type === 'gap') {
                             loadPromise = new Promise(function (resolve, reject) {
-                                _this._fillGap(null, vodResponse.desiredDuration)
+                                _this._fillGap(null, vodResponse.desiredDuration, vodResponse.unixTs)
                                     .then(function (gapVod) {
                                     currentVod = gapVod;
                                     resolve(gapVod);
                                 }).catch(reject);
                             });
                         }
-                        _u.label = 16;
-                    case 16:
+                        _u.label = 17;
+                    case 17:
                         loadStart = Date.now();
                         return [4 /*yield*/, loadPromise];
-                    case 17:
+                    case 18:
                         _u.sent();
                         cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'loadVod', channel: this._sessionId, loadTimeMs: Date.now() - loadStart });
                         debug("[".concat(this._sessionId, "]: first VOD loaded. DeltaTimes ").concat(currentVod.getDeltaTimes().map(roundToThreeDecimals).join(",")));
@@ -1813,7 +1800,7 @@ var Session = /** @class */ (function () {
                                 "vodMediaSeqSubtitle": 0,
                                 "state": SessionState.VOD_PLAYING
                             })];
-                    case 18:
+                    case 19:
                         updatedSessionState = _u.sent();
                         sessionState = __assign(__assign({}, sessionState), updatedSessionState);
                         this.produceEvent({
@@ -1825,29 +1812,29 @@ var Session = /** @class */ (function () {
                         });
                         _d = sessionState;
                         return [4 /*yield*/, this._sessionState.setCurrentVod(currentVod, { ttl: currentVod.getDuration() * 1000 })];
-                    case 19:
+                    case 20:
                         _d.currentVod = _u.sent();
                         _e = this;
                         return [4 /*yield*/, this._playheadState.set("playheadRef", Date.now(), isLeader)];
-                    case 20:
+                    case 21:
                         _e.currentPlayheadRef = _u.sent();
                         return [4 /*yield*/, this._sessionState.remove("nextVod")];
-                    case 21:
+                    case 22:
                         _u.sent();
                         return [2 /*return*/];
-                    case 22:
+                    case 23:
                         debug("[".concat(this._sessionId, "]: not a leader so will go directly to state VOD_PLAYING"));
                         _f = sessionState;
                         return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_PLAYING)];
-                    case 23:
+                    case 24:
                         _f.state = _u.sent();
                         _g = sessionState;
                         return [4 /*yield*/, this._sessionState.getCurrentVod()];
-                    case 24:
+                    case 25:
                         _g.currentVod = _u.sent();
                         return [2 /*return*/];
-                    case 25: return [3 /*break*/, 29];
-                    case 26:
+                    case 26: return [3 /*break*/, 31];
+                    case 27:
                         err_5 = _u.sent();
                         console.error("[".concat(this._sessionId, "]: Failed to init first VOD"));
                         if (this._assetManager.handleError) {
@@ -1856,18 +1843,22 @@ var Session = /** @class */ (function () {
                         cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'error', on: 'firstvod', channel: this._sessionId, err: err_5, vod: vodResponse });
                         debug(err_5);
                         return [4 /*yield*/, this._sessionState.remove("nextVod")];
-                    case 27:
+                    case 28:
                         _u.sent();
                         return [4 /*yield*/, this._insertSlate(currentVod)];
-                    case 28:
+                    case 29:
                         currentVod = _u.sent();
                         if (!currentVod) {
                             debug("No slate to load");
                             throw err_5;
                         }
-                        return [3 /*break*/, 29];
-                    case 29:
-                        if (!isLeader) return [3 /*break*/, 33];
+                        return [4 /*yield*/, this._sessionState.getValues(["state", "assetId", "vodMediaSeqVideo", "vodMediaSeqAudio", "vodMediaSeqSubtitle", "mediaSeq", "mediaSeqAudio", "mediaSeqSubtitle", "discSeq", "discSeqAudio", "discSeqSubtitle", "nextVod"])];
+                    case 30:
+                        // Re-read sessionState after _insertSlate modified it in Redis
+                        sessionState = _u.sent();
+                        return [3 /*break*/, 31];
+                    case 31:
+                        if (!isLeader) return [3 /*break*/, 35];
                         // Handle edge case where store has been reset, but leader has not cleared cache.
                         if (this.prevVodMediaSeq.video === null) {
                             this.prevVodMediaSeq.video = sessionState.vodMediaSeqVideo;
@@ -1891,20 +1882,20 @@ var Session = /** @class */ (function () {
                                 this.prevMediaSeqOffset.subtitle = sessionState.mediaSeqSubtitle;
                             }
                         }
-                        if (!(sessionState.vodMediaSeqVideo < this.prevVodMediaSeq.video)) return [3 /*break*/, 32];
+                        if (!(sessionState.vodMediaSeqVideo < this.prevVodMediaSeq.video)) return [3 /*break*/, 34];
                         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 30:
+                    case 32:
                         _u.sent();
                         return [4 /*yield*/, this._sessionState.getCurrentVod()];
-                    case 31:
+                    case 33:
                         currentVod = _u.sent();
                         this.prevVodMediaSeq.video = sessionState.vodMediaSeqVideo;
                         this.prevVodMediaSeq.audio = sessionState.vodMediaSeqAudio;
                         this.prevVodMediaSeq.subtitle = sessionState.vodMediaSeqSubtitle;
-                        _u.label = 32;
-                    case 32: return [3 /*break*/, 34];
-                    case 33:
+                        _u.label = 34;
+                    case 34: return [3 /*break*/, 36];
+                    case 35:
                         // 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(), "]"));
@@ -1912,11 +1903,11 @@ var Session = /** @class */ (function () {
                             // Allow Follower to clear VodCache...
                             this.isAllowedToClearVodCache = true;
                         }
-                        _u.label = 34;
-                    case 34:
+                        _u.label = 36;
+                    case 36:
                         debug("[".concat(this._sessionId, "]: state=VOD_PLAYING (").concat(sessionState.vodMediaSeqVideo, "_").concat(sessionState.vodMediaSeqAudio, "_").concat(sessionState.vodMediaSeqSubtitle, ", ").concat(currentVod.getLiveMediaSequencesCount(), "_").concat(currentVod.getLiveMediaSequencesCount("audio"), "_").concat(currentVod.getLiveMediaSequencesCount("subtitle"), ")"));
                         return [2 /*return*/];
-                    case 35:
+                    case 37:
                         debug("[".concat(this._sessionId, "]: state=VOD_NEXT_INITIATING (").concat(sessionState.vodMediaSeqVideo, "_").concat(sessionState.vodMediaSeqAudio, "_").concat(sessionState.vodMediaSeqSubtitle, ", ").concat(currentVod.getLiveMediaSequencesCount(), "_").concat(currentVod.getLiveMediaSequencesCount("audio"), "_").concat(currentVod.getLiveMediaSequencesCount("subtitle"), ")"));
                         if (!isLeader) {
                             debug("[".concat(this._sessionId, "]: not the leader so just waiting for the VOD to be initiated"));
@@ -1924,18 +1915,18 @@ var Session = /** @class */ (function () {
                         // Allow Leader|Follower to clear vodCache...
                         this.isAllowedToClearVodCache = true;
                         return [2 /*return*/];
-                    case 36:
-                        _u.trys.push([36, 63, , 66]);
+                    case 38:
+                        _u.trys.push([38, 65, , 69]);
                         debug("[".concat(this._sessionId, "]: state=VOD_NEXT_INIT"));
-                        if (!isLeader) return [3 /*break*/, 58];
-                        if (!!currentVod) return [3 /*break*/, 38];
+                        if (!isLeader) return [3 /*break*/, 60];
+                        if (!!currentVod) return [3 /*break*/, 40];
                         debug("[".concat(this._sessionId, "]: no VOD to append to, assume first VOD to init"));
                         _h = sessionState;
                         return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_INIT)];
-                    case 37:
+                    case 39:
                         _h.state = _u.sent();
                         return [2 /*return*/];
-                    case 38:
+                    case 40:
                         length_1 = currentVod.getLiveMediaSequencesCount();
                         endMseqValue = void 0;
                         endMseqValueAudio = void 0;
@@ -1955,28 +1946,28 @@ var Session = /** @class */ (function () {
                         lastDiscontinuitySubtitle = currentVod.getLastDiscontinuitySubtitle();
                         _j = sessionState;
                         return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_NEXT_INITIATING)];
-                    case 39:
+                    case 41:
                         _j.state = _u.sent();
                         vodPromise = this._getNextVod();
-                        if (!(length_1 === 1)) return [3 /*break*/, 41];
+                        if (!(length_1 === 1)) return [3 /*break*/, 43];
                         gracePeriod = (this.averageSegmentDuration / 2);
                         debug("[".concat(this._sessionId, "]: adding a grace period before calling nextVod: ").concat(gracePeriod, "ms"));
                         return [4 /*yield*/, timer(gracePeriod)];
-                    case 40:
+                    case 42:
                         _u.sent();
-                        _u.label = 41;
-                    case 41:
+                        _u.label = 43;
+                    case 43:
                         nextVodStart = Date.now();
                         return [4 /*yield*/, vodPromise];
-                    case 42:
+                    case 44:
                         vodResponse = _u.sent();
                         _k = sessionState;
                         return [4 /*yield*/, this._sessionState.set("nextVod", vodResponse)];
-                    case 43:
+                    case 45:
                         _k.nextVod = _u.sent();
                         cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'nextVod', channel: this._sessionId, reqTimeMs: Date.now() - nextVodStart });
                         loadPromise = void 0;
-                        if (!!vodResponse.type) return [3 /*break*/, 50];
+                        if (!!vodResponse.type) return [3 /*break*/, 52];
                         debug("[".concat(this._sessionId, "]: got next VOD uri=").concat(vodResponse.uri, ":").concat(vodResponse.offset));
                         hlsOpts = {
                             sequenceAlwaysContainNewSegments: this.alwaysNewSegments,
@@ -2003,25 +1994,25 @@ var Session = /** @class */ (function () {
                                 title: this.currentMetadata.title || '',
                             }
                         });
-                        if (!vodResponse.desiredDuration) return [3 /*break*/, 48];
-                        _u.label = 44;
-                    case 44:
-                        _u.trys.push([44, 46, , 47]);
+                        if (!vodResponse.desiredDuration) return [3 /*break*/, 50];
+                        _u.label = 46;
+                    case 46:
+                        _u.trys.push([46, 48, , 49]);
                         return [4 /*yield*/, this._truncateVod(vodResponse)];
-                    case 45:
+                    case 47:
                         _l = _u.sent(), mediaManifestLoader = _l.mediaManifestLoader, audioManifestLoader = _l.audioManifestLoader, subtitleManifestLoader = _l.subtitleManifestLoader;
                         loadPromise = newVod.loadAfter(currentVod, null, mediaManifestLoader, audioManifestLoader, subtitleManifestLoader);
-                        return [3 /*break*/, 47];
-                    case 46:
+                        return [3 /*break*/, 49];
+                    case 48:
                         e_2 = _u.sent();
                         console.error("[".concat(this._sessionId, "]: Failed to truncate VOD: ").concat(e_2));
                         loadPromise = newVod.loadAfter(currentVod);
-                        return [3 /*break*/, 47];
-                    case 47: return [3 /*break*/, 49];
-                    case 48:
+                        return [3 /*break*/, 49];
+                    case 49: return [3 /*break*/, 51];
+                    case 50:
                         loadPromise = newVod.loadAfter(currentVod);
-                        _u.label = 49;
-                    case 49:
+                        _u.label = 51;
+                    case 51:
                         if (vodResponse.diffMs) {
                             this.diffCompensation = vodResponse.diffMs;
                             if (this.diffCompensation) {
@@ -2032,20 +2023,20 @@ var Session = /** @class */ (function () {
                                 this.timePositionOffset = 0;
                             }
                         }
-                        return [3 /*break*/, 51];
-                    case 50:
+                        return [3 /*break*/, 53];
+                    case 52:
                         loadPromise = new Promise(function (resolve, reject) {
-                            _this._fillGap(currentVod, vodResponse.desiredDuration)
+                            _this._fillGap(currentVod, vodResponse.desiredDuration, vodResponse.unixTs)
                                 .then(function (gapVod) {
                                 newVod = gapVod;
                                 resolve(newVod);
                             }).catch(reject);
                         });
-                        _u.label = 51;
-                    case 51:
+                        _u.label = 53;
+                    case 53:
                         loadStart = Date.now();
                         return [4 /*yield*/, ChaosMonkey.loadVod(loadPromise)];
-                    case 52:
+                    case 54:
                         _u.sent();
                         cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'loadVod', channel: this._sessionId, loadTimeMs: Date.now() - loadStart });
                         this.leaderIsSettingNextVod = true;
@@ -2055,11 +2046,11 @@ var Session = /** @class */ (function () {
                         debug("[".concat(this._sessionId, "]: msequences=").concat(currentVod.getLiveMediaSequencesCount(), "; audio msequences=").concat(currentVod.getLiveMediaSequencesCount("audio"), "; subtitle msequences=").concat(currentVod.getLiveMediaSequencesCount("subtitle")));
                         _m = sessionState;
                         return [4 /*yield*/, this._sessionState.setCurrentVod(currentVod, { ttl: currentVod.getDuration() * 1000 })];
-                    case 53:
+                    case 55:
                         _m.currentVod = _u.sent();
                         _o = this;
                         return [4 /*yield*/, this._playheadState.set("playheadRef", Date.now(), isLeader)];
-                    case 54:
+                    case 56:
                         _o.currentPlayheadRef = _u.sent();
                         return [4 /*yield*/, this._sessionState.setValues({
                                 "vodMediaSeqVideo": 0,
@@ -2072,16 +2063,16 @@ var Session = /** @class */ (function () {
                                 "discSeqAudio": sessionState.discSeqAudio + lastDiscontinuityAudio,
                                 "discSeqSubtitle": sessionState.discSeqSubtitle + lastDiscontinuitySubtitle
                             })];
-                    case 55:
+                    case 57:
                         updatedSessionState = _u.sent();
                         sessionState = __assign(__assign({}, sessionState), updatedSessionState);
                         debug("[".concat(this._sessionId, "]: new sequence data set in store V[").concat(sessionState.mediaSeq, "][").concat(sessionState.discSeq, "]_A[").concat(sessionState.mediaSeqAudio, "][").concat(sessionState.discSeqAudio, "]_S[").concat(sessionState.mediaSeqSubtitle, "][").concat(sessionState.discSeqSubtitle, "]"));
                         return [4 /*yield*/, this._sessionState.remove("nextVod")];
-                    case 56:
+                    case 58:
                         _u.sent();
                         this.leaderIsSettingNextVod = false;
                         return [4 /*yield*/, this._playheadState.set("diffCompensation", this.diffCompensation, isLeader)];
-                    case 57:
+                    case 59:
                         _u.sent();
                         debug("[".concat(this._sessionId, "]: sharing current vods diffCompensation=").concat(this.diffCompensation));
                         this.produceEvent({
@@ -2092,21 +2083,21 @@ var Session = /** @class */ (function () {
                             }
                         });
                         return [2 /*return*/];
-                    case 58:
+                    case 60:
                         debug("[".concat(this._sessionId, "]: not a leader so will go directly to state VOD_NEXT_INITIATING"));
                         this.waitingForNextVod = true;
                         _p = sessionState;
                         return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_NEXT_INITIATING)];
-                    case 59:
+                    case 61:
                         _p.state = _u.sent();
                         // Allow Leader|Follower to clear vodCache...
                         this.isAllowedToClearVodCache = true;
                         _q = sessionState;
                         return [4 /*yield*/, this._sessionState.getCurrentVod()];
-                    case 60:
+                    case 62:
                         _q.currentVod = _u.sent();
                         return [4 /*yield*/, this._playheadState.get("diffCompensation")];
-                    case 61:
+                    case 63:
                         diffMs = _u.sent();
                         if (diffMs) {
                             this.diffCompensation = diffMs;
@@ -2119,9 +2110,9 @@ var Session = /** @class */ (function () {
                                 this.timePositionOffset = 0;
                             }
                         }
-                        _u.label = 62;
-                    case 62: return [3 /*break*/, 66];
-                    case 63:
+                        _u.label = 64;
+                    case 64: return [3 /*break*/, 69];
+                    case 65:
                         err_6 = _u.sent();
                         console.error("[".concat(this._sessionId, "]: Failed to init next VOD"));
                         debug("[".concat(this._sessionId, "]: ").concat(err_6));
@@ -2130,31 +2121,35 @@ var Session = /** @class */ (function () {
                         }
                         cloudWatchLog(!this.cloudWatchLogging, 'engine-session', { event: 'error', on: 'nextvod', channel: this._sessionId, err: err_6, vod: vodResponse });
                         return [4 /*yield*/, this._sessionState.remove("nextVod")];
-                    case 64:
+                    case 66:
                         _u.sent();
                         return [4 /*yield*/, this._insertSlate(currentVod)];
-                    case 65:
+                    case 67:
                         currentVod = _u.sent();
                         if (!currentVod) {
                             debug("No slate to load");
                             throw err_6;
                         }
+                        return [4 /*yield*/, this._sessionState.getValues(["state", "assetId", "vodMediaSeqVideo", "vodMediaSeqAudio", "vodMediaSeqSubtitle", "mediaSeq", "mediaSeqAudio", "mediaSeqSubtitle", "discSeq", "discSeqAudio", "discSeqSubtitle", "nextVod"])];
+                    case 68:
+                        // Re-read sessionState after _insertSlate modified it in Redis
+                        sessionState = _u.sent();
                         // Allow Leader|Follower to clear vodCache...
                         this.isAllowedToClearVodCache = true;
-                        return [3 /*break*/, 66];
-                    case 66: return [3 /*break*/, 101];
-                    case 67:
-                        _u.trys.push([67, 94, , 95]);
+                        return [3 /*break*/, 69];
+                    case 69: return [3 /*break*/, 105];
+                    case 70:
+                        _u.trys.push([70, 98, , 99]);
                         debug("[".concat(this._sessionId, "]: state=VOD_RELOAD_INIT"));
                         if (this.diffCompensation <= 0) {
                             this.diffCompensation = 0.1;
                         }
-                        if (!isLeader) return [3 /*break*/, 91];
+                        if (!isLeader) return [3 /*break*/, 95];
                         startTS = Date.now();
                         // 1) To tell Follower that, Leader is working on it!
                         _r = sessionState;
                         return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_RELOAD_INITIATING)];
-                    case 68:
+                    case 71:
                         // 1) To tell Follower that, Leader is working on it!
                         _r.state = _u.sent();
                         mseqV_1 = this.switchDataForSession.mediaSeq;
@@ -2162,7 +2157,7 @@ var Session = /** @class */ (function () {
                         discSeqV_1 = this.switchDataForSession.discSeq;
                         discSeqA = this.switchDataForSession.discAudioSeq;
                         return [4 /*yield*/, this._sessionState.getCurrentVod()];
-                    case 69:
+                    case 72:
                         currentVod_1 = _u.sent();
                         if (currentVod_1.sequenceAlwaysContainNewSegments) {
                             // (!) will need to compensate if using this setting on HLSVod Object.
@@ -2217,87 +2212,87 @@ var Session = /** @class */ (function () {
                             return [2 /*return*/];
                         }
                         return [4 /*yield*/, this._sessionState.set("mediaSeq", mseqV_1)];
-                    case 70:
+                    case 73:
                         _u.sent();
                         return [4 /*yield*/, this._playheadState.set("mediaSeq", mseqV_1, isLeader)];
-                    case 71:
+                    case 74:
                         _u.sent();
                         return [4 /*yield*/, this._sessionState.set("discSeq", discSeqV_1)];
-                    case 72:
+                    case 75:
                         _u.sent();
                         // TODO: support demux^
                         debug("[".concat(this._sessionId, "]: Setting current media and discontinuity count -> [").concat(mseqV_1, "]:[").concat(discSeqV_1, "]"));
-                        if (!this.use_demuxed_audio) return [3 /*break*/, 76];
+                        if (!this.use_demuxed_audio) return [3 /*break*/, 79];
                         return [4 /*yield*/, this._sessionState.set("mediaSeqAudio", mseqA)];
-                    case 73:
+                    case 76:
                         _u.sent();
                         return [4 /*yield*/, this._playheadState.set("mediaSeqAudio", mseqA, isLeader)];
-                    case 74:
+                    case 77:
                         _u.sent();
                         return [4 /*yield*/, this._sessionState.set("discSeqAudio", discSeqA)];
-                    case 75:
+                    case 78:
                         _u.sent();
                         debug("[".concat(this._sessionId, "]: Setting current audio media and discontinuity count -> [").concat(mseqA, "]:[").concat(discSeqA, "]"));
-                        _u.label = 76;
-                    case 76:
+                        _u.label = 79;
+                    case 79:
                         // 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 77:
+                    case 80:
                         playheadState = _u.sent();
                         nextMseq = playheadState.vodMediaSeqVideo + 1;
                         if (nextMseq > currentVod_1.getLiveMediaSequencesCount() - 1) {
                             nextMseq = currentVod_1.getLiveMediaSequencesCount() - 1;
                         }
-                        if (!this.use_demuxed_audio) return [3 /*break*/, 79];
+                        if (!this.use_demuxed_audio) return [3 /*break*/, 82];
                         return [4 /*yield*/, this._playheadState.getValues(["vodMediaSeqAudio"])];
-                    case 78:
+                    case 81:
                         playheadStateAudio = _u.sent();
                         nextAudioMseq = playheadStateAudio.vodMediaSeqAudio + 1;
                         if (nextAudioMseq > currentVod_1.getLiveMediaSequencesCount("audio") - 1) {
                             nextAudioMseq = currentVod_1.getLiveMediaSequencesCount("audio") - 1;
                         }
-                        _u.label = 79;
-                    case 79: 
+                        _u.label = 82;
+                    case 82: 
                     // ---------------------------------------------------.
                     // TODO: Support reloading with SubtitleSegments as well |
                     // ---------------------------------------------------'
                     return [4 /*yield*/, currentVod_1.reload(nextMseq, segments, audioSegments, reloadBehind)];
-                    case 80:
+                    case 83:
                         // ---------------------------------------------------.
                         // TODO: Support reloading with SubtitleSegments as well |
                         // ---------------------------------------------------'
                         _u.sent();
                         return [4 /*yield*/, this._sessionState.setCurrentVod(currentVod_1, { ttl: currentVod_1.getDuration() * 1000 })];
-                    case 81:
+                    case 84:
                         _u.sent();
                         return [4 /*yield*/, this._sessionState.set("vodReloaded", 1)];
-                    case 82:
+                    case 85:
                         _u.sent();
                         return [4 /*yield*/, this._sessionState.set("vodMediaSeqVideo", 0)];
-                    case 83:
+                    case 86:
                         _u.sent();
                         return [4 /*yield*/, this._playheadState.set("vodMediaSeqVideo", 0, isLeader)];
-                    case 84:
+                    case 87:
                         _u.sent();
-                        if (!this.use_demuxed_audio) return [3 /*break*/, 89];
+                        if (!this.use_demuxed_audio) return [3 /*break*/, 92];
                         return [4 /*yield*/, this._sessionState.set("vodMediaSeqAudio", 0)];
-                    case 85:
+                    case 88:
                         _u.sent();
                         return [4 /*yield*/, this._playheadState.set("vodMediaSeqAudio", 0, isLeader)];
-                    case 86:
+                    case 89:
                         _u.sent();
                         return [4 /*yield*/, this._sessionState.set("vodMediaSeqSubtitle", 0)];
-                    case 87:
+                    case 90:
                         _u.sent();
                         return [4 /*yield*/, this._playheadState.set("vodMediaSeqSubtitle", 0, isLeader)];
-                    case 88:
+                    case 91:
                         _u.sent();
-                        _u.label = 89;
-                    case 89:
+                        _u.label = 92;
+                    case 92:
                         _s = this;
                         return [4 /*yield*/, this._playheadState.set("playheadRef", Date.now(), isLeader)];
-                    case 90:
+                    case 93:
                         _s.currentPlayheadRef = _u.sent();
                         // 4) Log to debug and cloudwatch
                         debug("[".concat(this._sessionId, "]: LEADER: Set new Reloaded VOD and vodMediaSeq counts in store."));
@@ -2313,39 +2308,48 @@ var Session = /** @class */ (function () {
                             channel: this._sessionId,
                             reqTimeMs: Date.now() - startTS,
                         });
+                        return [4 /*yield*/, this._sessionState.getValues(["state", "assetId", "vodMediaSeqVideo", "vodMediaSeqAudio", "vodMediaSeqSubtitle", "mediaSeq", "mediaSeqAudio", "mediaSeqSubtitle", "discSeq", "discSeqAudio", "discSeqSubtitle", "nextVod"])];
+                    case 94:
+                        // Re-read sessionState after individual set() calls modified it in Redis
+                        sessionState = _u.sent();
                         return [2 /*return*/];
-                    case 91:
+                    case 95:
                         debug("[".concat(this._sessionId, "]: not a leader so will go directly to state VOD_RELOAD_INITIATING"));
                         _t = sessionState;
                         return [4 /*yield*/, this._sessionState.set("state", SessionState.VOD_RELOAD_INITIATING)];
-                    case 92:
+                    case 96:
                         _t.state = _u.sent();
-                        _u.label = 93;
-                    case 93: return [3 /*break*/, 95];
-                    case 94:
+                        _u.label = 97;
+                    case 97: return [3 /*break*/, 99];
+                    case 98:
                         err_7 = _u.sent();
                         debug("Failed to init reload vod");
                         throw err_7;
-                    case 95: return [3 /*break*/, 101];
-                    case 96:
+                    case 99: return [3 /*break*/, 105];
+                    case 100:
                         debug("[".concat(this._sessionId, "]: state=VOD_RELOAD_INITIATING (").concat(sessionState.vodMediaSeqVideo, "_").concat(sessionState.vodMediaSeqAudio, "_").concat(sessionState.vodMediaSeqSubtitle, ", ").concat(currentVod.getLiveMediaSequencesCount(), "_").concat(currentVod.getLiveMediaSequencesCount("audio"), "_").concat(currentVod.getLiveMediaSequencesCount("subtitle"), ")"));
-                        if (!!isLeader) return [3 /*break*/, 99];
+                        if (!!isLeader) return [3 /*break*/, 103];
                         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*/, 98];
+                        if (!(sessionState.vodMediaSeqVideo === 0 || this.waitingForNextVod)) return [3 /*break*/, 102];
                         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 97:
+                    case 101:
                         _u.sent();
-                        _u.label = 98;
-                    case 98:
+                        _u.label = 102;
+                    case 102:
                         this.waitingForNextVod = true;
-                        _u.label = 99;
-                    case 99:
+                        _u.label = 103;
+                    case 103:
                         // Allow Leader|Follower to clear vodCache...
                         this.isAllowedToClearVodCache = true;
                         return [2 /*return*/];
-                    case 100: throw new Error("Invalid state: " + sessionState.state);
-                    case 101: return [2 /*return*/];
+                    case 104: throw new Error("Invalid state: " + sessionState.state);
+                    case 105: return [3 /*break*/, 107];
+                    case 106:
+                        // Store tick state for incrementAsync to reuse, avoiding redundant Redis reads
+                        this._lastTickState = { sessionState: sessionState, isLeader: isLeader, currentVod: currentVod };
+                        return [7 /*endfinally*/];
+                    case 107: return [2 /*return*/];
                 }
             });
         });
@@ -2382,7 +2386,7 @@ var Session = /** @class */ (function () {
                 .catch(reject);
         });
     };
-    Session.prototype._loadSlate = function (afterVod, reps) {
+    Session.prototype._loadSlate = function (afterVod, reps, unixTs) {
         var _this = this;
         return new Promise(function (resolve, reject) {
             try {
@@ -2401,7 +2405,7 @@ var Session = /** @class */ (function () {
                         skipSerializeMediaSequences: _this.partialStoreHLSVod,
                         calculatePDT: _this.rollingPDT
                     };
-                    var timestamp = Date.now();
+                    var timestamp = unixTs ? unixTs : Date.now();
                     hlsVod_1 = new HLSVod(_this.slateUri, null, timestamp, null, m3u8Header(_this._instanceId), hlsOpts);
                     hlsVod_1.addMetadata('id', "slate-".concat(timestamp));
                     hlsVod_1.addMetadata('start-date', new Date(timestamp).toISOString());
@@ -2503,7 +2507,7 @@ var Session = /** @class */ (function () {
             }
         });
     };
-    Session.prototype._truncateSlate = function (afterVod, requestedDuration, vodUri) {
+    Session.prototype._truncateSlate = function (afterVod, requestedDuration, vodUri, unixTs) {
         var _this = this;
         return new Promise(function (resolve, reject) {
             var nexVodUri = null;
@@ -2529,7 +2533,7 @@ var Session = /** @class */ (function () {
                         skipSerializeMediaSequences: _this.partialStoreHLSVod,
                         calculatePDT: _this.rollingPDT
                     };
-                    var timestamp = Date.now();
+                    var timestamp = unixTs ? unixTs : Date.now();
                     hlsVod_2 = new HLSVod(nexVodUri, null, timestamp, null, m3u8Header(_this._instanceId), hlsOpts);
                     hlsVod_2.addMetadata('id', "slate-".concat(timestamp));
                     hlsVod_2.addMetadata('start-date', new Date(timestamp).toISOString());
@@ -2586,7 +2590,7 @@ var Session = /** @class */ (function () {
             }
         });
     };
-    Session.prototype._fillGap = function (afterVod, desiredDuration) {
+    Session.prototype._fillGap = function (afterVod, desiredDuration, unixTs) {
         var _this = this;
         return new Promise(function (resolve, reject) {
             var loadSlatePromise;
@@ -2594,12 +2598,12 @@ var Session = /** @class */ (function () {
             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);
+                loadSlatePromise = _this._loadSlate(afterVod, reps, unixTs);
                 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);
+                loadSlatePromise = _this._truncateSlate(afterVod, desiredDuration / 1000, null, unixTs);
                 durationMs = desiredDuration;
             }
             loadSlatePromise.then(function (hlsVod) {