@guardvideo/player-sdk 3.4.0 → 3.6.0

package/dist/vanilla/guardvideo-player.js

@@ -36692,8 +36692,19 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
       }
   }
 
+  const VALID_EVENT_TYPES = [
+      'watch_chunk',
+      'play',
+      'pause',
+      'seek',
+      'ended',
+      'quality_change',
+      'error',
+      'security_event',
+  ];
   const MAX_BATCH_SIZE = 25;
   const DEFAULT_FLUSH_INTERVAL = 5000;
+  const MAX_FLUSH_BACKOFF = 60000;
   class EventTracker {
       constructor(config) {
           this.buffer = [];
@@ -36701,6 +36712,8 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
           this.accumulator = new WatchChunkAccumulator();
           this.destroyed = false;
           this._onBeforeUnload = null;
+          this.flushBackoff = 0;
+          this.flushing = false;
           this.config = {
               endpoint: config.endpoint,
               tokenId: config.tokenId,
@@ -36716,6 +36729,12 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
       track(type, positionSeconds, payload) {
           if (this.destroyed)
               return;
+          if (!VALID_EVENT_TYPES.includes(type)) {
+              if (this.config.debug) {
+                  console.warn('[GuardVideo EventTracker] Skipping unknown event type:', type);
+              }
+              return;
+          }
           this.buffer.push({
               event_type: type,
               event_at: new Date().toISOString(),
@@ -36739,7 +36758,7 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
           this.config.sessionId = sessionId;
       }
       async flush() {
-          if (this.destroyed)
+          if (this.destroyed || this.flushing)
               return;
           const chunks = this.accumulator.drain();
           for (const c of chunks) {
@@ -36747,8 +36766,14 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
           }
           if (this.buffer.length === 0)
               return;
-          const batch = this.buffer.splice(0, MAX_BATCH_SIZE);
-          await this.sendBatch(batch);
+          this.flushing = true;
+          try {
+              const batch = this.buffer.splice(0, MAX_BATCH_SIZE);
+              await this.sendBatch(batch);
+          }
+          finally {
+              this.flushing = false;
+          }
       }
       destroy() {
           this.destroyed = true;
@@ -36763,6 +36788,11 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
       startAutoFlush() {
           this.flushTimer = setInterval(() => this.flush(), this.config.flushIntervalMs);
       }
+      restartAutoFlush(intervalMs) {
+          if (this.flushTimer)
+              clearInterval(this.flushTimer);
+          this.flushTimer = setInterval(() => this.flush(), intervalMs);
+      }
       hookPageUnload() {
           if (typeof window === 'undefined')
               return;
@@ -36808,8 +36838,25 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
                   body,
                   credentials: 'omit',
               });
-              if (!resp.ok && this.config.debug) {
-                  console.warn('[GuardVideo EventTracker] Flush failed:', resp.status);
+              if (!resp.ok) {
+                  if (resp.status === 429) {
+                      this.flushBackoff = Math.min((this.flushBackoff || this.config.flushIntervalMs) * 2, MAX_FLUSH_BACKOFF);
+                      if (this.config.debug) {
+                          console.warn('[GuardVideo EventTracker] 429 — backing off to', this.flushBackoff, 'ms');
+                      }
+                      this.buffer.unshift(...events);
+                      this.restartAutoFlush(this.flushBackoff);
+                      return;
+                  }
+                  if (this.config.debug) {
+                      console.warn('[GuardVideo EventTracker] Flush failed:', resp.status);
+                  }
+              }
+              else {
+                  if (this.flushBackoff > 0) {
+                      this.flushBackoff = 0;
+                      this.restartAutoFlush(this.config.flushIntervalMs);
+                  }
               }
           }
           catch (err) {
@@ -37025,6 +37072,15 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
           this._onSecurityEvent = null;
           this.playlistNonce = null;
           this.nonceRefreshInProgress = false;
+          this.nonceRefreshTimer = null;
+          this.retryBackoff = 1000;
+          this.MAX_BACKOFF = 30000;
+          this.rateLimitCooldownUntil = 0;
+          this.nonceRefreshPromise = null;
+          this.destroyed = false;
+          this.networkRetryCount = 0;
+          this.MAX_NETWORK_RETRIES = 6;
+          this.pendingRetryTimer = null;
           this._onRateChange = this.enforceMaxRate.bind(this);
           this.videoElement = videoElement;
           this.config = {
@@ -37235,9 +37291,18 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
       async solveChallenge(tokenId) {
           if (!this.config.apiBaseUrl)
               return undefined;
+          if (Date.now() < this.rateLimitCooldownUntil) {
+              this.log('Challenge skipped — rate limit cooldown active');
+              return undefined;
+          }
           try {
               const url = this.config.apiBaseUrl + '/videos/challenge/' + encodeURIComponent(tokenId);
               const resp = await fetch(url, { credentials: 'omit' });
+              if (resp.status === 429) {
+                  this.enterRateLimitCooldown();
+                  this.log('Challenge hit 429 — entering cooldown');
+                  return undefined;
+              }
               if (!resp.ok) {
                   this.log('Challenge fetch failed (challenge may be disabled)', resp.status);
                   return undefined;
@@ -37263,6 +37328,10 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
       async acquireNonce(tokenId) {
           if (!this.config.apiBaseUrl)
               return null;
+          if (Date.now() < this.rateLimitCooldownUntil) {
+              this.log('Nonce acquisition skipped — rate limit cooldown active');
+              return this.playlistNonce;
+          }
           try {
               const challengeResult = await this.solveChallenge(tokenId);
               const url = this.config.apiBaseUrl + '/videos/playlist-session';
@@ -37276,12 +37345,20 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
                   body: JSON.stringify(body),
                   credentials: 'omit',
               });
+              if (resp.status === 429) {
+                  this.enterRateLimitCooldown();
+                  this.log('Nonce acquisition hit 429 — entering cooldown');
+                  return this.playlistNonce;
+              }
               if (!resp.ok) {
                   this.log('Playlist session nonce acquisition failed', resp.status);
                   return null;
               }
               const data = await resp.json();
               this.log('Playlist nonce acquired, expires in ' + data.expiresIn + 's');
+              this.retryBackoff = 1000;
+              this.networkRetryCount = 0;
+              this.scheduleNonceRefresh(data.expiresIn);
               return data.nonce;
           }
           catch (err) {
@@ -37289,19 +37366,58 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
               return null;
           }
       }
+      scheduleNonceRefresh(expiresInSeconds) {
+          if (this.nonceRefreshTimer)
+              clearTimeout(this.nonceRefreshTimer);
+          const refreshMs = Math.max(5000, expiresInSeconds * 750);
+          this.nonceRefreshTimer = setTimeout(() => {
+              if (this.destroyed)
+                  return;
+              this.refreshNonce().catch(() => {
+                  this.log('Proactive nonce refresh failed');
+              });
+          }, refreshMs);
+      }
       async refreshNonce() {
-          if (this.nonceRefreshInProgress)
-              return;
+          if (this.nonceRefreshInProgress && this.nonceRefreshPromise) {
+              return this.nonceRefreshPromise;
+          }
           if (!this.embedToken)
               return;
           this.nonceRefreshInProgress = true;
-          try {
-              const nonce = await this.acquireNonce(this.embedToken.tokenId);
-              this.playlistNonce = nonce;
-          }
-          finally {
-              this.nonceRefreshInProgress = false;
-          }
+          this.nonceRefreshPromise = (async () => {
+              try {
+                  const nonce = await this.acquireNonce(this.embedToken.tokenId);
+                  this.playlistNonce = nonce;
+              }
+              finally {
+                  this.nonceRefreshInProgress = false;
+                  this.nonceRefreshPromise = null;
+              }
+          })();
+          return this.nonceRefreshPromise;
+      }
+      enterRateLimitCooldown() {
+          this.rateLimitCooldownUntil = Date.now() + this.retryBackoff;
+          this.retryBackoff = Math.min(this.retryBackoff * 2, this.MAX_BACKOFF);
+      }
+      scheduleRetry(fn, delayMs) {
+          if (this.pendingRetryTimer)
+              clearTimeout(this.pendingRetryTimer);
+          this.pendingRetryTimer = setTimeout(() => {
+              this.pendingRetryTimer = null;
+              if (!this.destroyed && this.hls)
+                  fn();
+          }, delayMs);
+      }
+      stopLoading() {
+          if (this.pendingRetryTimer) {
+              clearTimeout(this.pendingRetryTimer);
+              this.pendingRetryTimer = null;
+          }
+          this.hls?.stopLoad();
+          this.networkRetryCount = 0;
+          this.retryBackoff = 1000;
       }
       async initializePlayer() {
           if (!this.embedToken) {
@@ -37341,8 +37457,12 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
               enableWorker: true,
               lowLatencyMode: false,
               liveSyncDurationCount: 3,
-              manifestLoadingMaxRetry: 6,
-              levelLoadingMaxRetry: 6,
+              manifestLoadingMaxRetry: 3,
+              manifestLoadingRetryDelay: 2000,
+              levelLoadingMaxRetry: 3,
+              levelLoadingRetryDelay: 2000,
+              fragLoadingMaxRetry: 4,
+              fragLoadingRetryDelay: 1000,
               xhrSetup(xhr, url) {
                   if (url.includes('/watermark-stream/') && url.includes('.m3u8')) {
                       if (self.playlistNonce) {
@@ -37350,10 +37470,6 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
                           const nonceUrl = url + separator + 'nonce=' + encodeURIComponent(self.playlistNonce);
                           xhr.open('GET', nonceUrl, true);
                           self.log('Injected nonce into playlist request');
-                          self.playlistNonce = null;
-                          self.refreshNonce().catch(() => {
-                              self.log('Background nonce refresh failed');
-                          });
                       }
                   }
               },
@@ -37365,6 +37481,8 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
               this.log('HLS manifest parsed', { levels: data.levels.map((l) => l.height + 'p') });
               this.setState(exports.PlayerState.READY);
               this.config.onReady();
+              this.retryBackoff = 1000;
+              this.networkRetryCount = 0;
               if (this.config.autoplay)
                   this.play();
           });
@@ -37380,28 +37498,77 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
               this.currentQuality = quality;
               this.log('Quality switched to ' + quality.name);
               this.config.onQualityChange(quality.name);
+              this.eventTracker?.track('quality_change', this.videoElement.currentTime, {
+                  level: data.level,
+                  height: level.height,
+                  bitrate: level.bitrate,
+              });
           });
           this.hls.on(Hls.Events.ERROR, (_event, data) => {
               this.error('HLS Error', data);
+              this.eventTracker?.track('error', this.videoElement.currentTime, {
+                  type: data.type,
+                  details: data.details,
+                  fatal: data.fatal,
+              });
+              if (this.destroyed)
+                  return;
+              if (Date.now() < this.rateLimitCooldownUntil) {
+                  this.log('Suppressing retry — rate limit cooldown active (' +
+                      Math.ceil((this.rateLimitCooldownUntil - Date.now()) / 1000) + 's remaining)');
+                  if (data.fatal) {
+                      const delay = this.rateLimitCooldownUntil - Date.now() + 500;
+                      this.scheduleRetry(() => this.hls?.startLoad(), delay);
+                  }
+                  return;
+              }
+              const httpStatus = data.response?.code;
+              if (httpStatus === 429) {
+                  this.enterRateLimitCooldown();
+                  this.log('429 detected — entering cooldown for ' + this.retryBackoff + 'ms');
+                  this.scheduleRetry(() => {
+                      if (this.embedToken?.forensicWatermark) {
+                          this.refreshNonce().then(() => this.hls?.startLoad()).catch(() => this.hls?.startLoad());
+                      }
+                      else {
+                          this.hls?.startLoad();
+                      }
+                  }, this.retryBackoff);
+                  return;
+              }
               if (data.type === Hls.ErrorTypes.NETWORK_ERROR &&
                   data.details === Hls.ErrorDetails.LEVEL_LOAD_ERROR &&
                   this.embedToken?.forensicWatermark) {
-                  this.log('Playlist load failed — refreshing nonce before retry');
+                  this.networkRetryCount++;
+                  if (this.networkRetryCount > this.MAX_NETWORK_RETRIES) {
+                      this.error('Max network retries exceeded for playlist load');
+                      this.handleError({ code: 'NETWORK_ERROR', message: 'Playlist load failed after multiple retries', fatal: true, details: data });
+                      return;
+                  }
+                  this.log('Playlist load failed — refreshing nonce before retry (' + this.networkRetryCount + '/' + this.MAX_NETWORK_RETRIES + ')');
                   this.refreshNonce().then(() => {
-                      setTimeout(() => this.hls?.startLoad(), 500);
+                      this.scheduleRetry(() => this.hls?.startLoad(), this.retryBackoff);
                   }).catch(() => {
-                      setTimeout(() => this.hls?.startLoad(), 1000);
+                      this.scheduleRetry(() => this.hls?.startLoad(), this.retryBackoff);
                   });
+                  this.retryBackoff = Math.min(this.retryBackoff * 1.5, this.MAX_BACKOFF);
                   return;
               }
               if (data.fatal) {
                   switch (data.type) {
                       case Hls.ErrorTypes.NETWORK_ERROR:
-                          this.error('Network error, attempting recovery...');
+                          this.networkRetryCount++;
+                          if (this.networkRetryCount > this.MAX_NETWORK_RETRIES) {
+                              this.error('Max network retries exceeded — giving up');
+                              this.handleError({ code: 'NETWORK_ERROR', message: 'Network error after multiple retries. Please check your connection.', fatal: true, details: data });
+                              return;
+                          }
+                          this.error('Network error, attempting recovery (' + this.networkRetryCount + '/' + this.MAX_NETWORK_RETRIES + ')...');
                           if (this.embedToken?.forensicWatermark) {
                               this.refreshNonce().catch(() => { });
                           }
-                          setTimeout(() => this.hls?.startLoad(), 1000);
+                          this.scheduleRetry(() => this.hls?.startLoad(), this.retryBackoff);
+                          this.retryBackoff = Math.min(this.retryBackoff * 1.5, this.MAX_BACKOFF);
                           break;
                       case Hls.ErrorTypes.MEDIA_ERROR:
                           this.error('Media error, attempting recovery...');
@@ -37415,8 +37582,21 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
           this.setupVideoEventListeners();
       }
       setupVideoEventListeners() {
-          this.videoElement.addEventListener('playing', () => this.setState(exports.PlayerState.PLAYING));
-          this.videoElement.addEventListener('pause', () => this.setState(exports.PlayerState.PAUSED));
+          this.videoElement.addEventListener('playing', () => {
+              this.setState(exports.PlayerState.PLAYING);
+              if (this.hls)
+                  this.hls.startLoad(-1);
+          });
+          this.videoElement.addEventListener('pause', () => {
+              this.setState(exports.PlayerState.PAUSED);
+              if (this.hls && !this.videoElement.seeking) {
+                  this.hls.stopLoad();
+                  if (this.pendingRetryTimer) {
+                      clearTimeout(this.pendingRetryTimer);
+                      this.pendingRetryTimer = null;
+                  }
+              }
+          });
           this.videoElement.addEventListener('waiting', () => this.setState(exports.PlayerState.BUFFERING));
           this.videoElement.addEventListener('error', () => {
               const error = this.videoElement.error;
@@ -37443,6 +37623,8 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
       }
       async play() {
           try {
+              this.networkRetryCount = 0;
+              this.retryBackoff = 1000;
               await this.videoElement.play();
           }
           catch (err) {
@@ -37479,6 +37661,15 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
       getState() { return this.state; }
       destroy() {
           this.log('Destroying player');
+          this.destroyed = true;
+          if (this.pendingRetryTimer) {
+              clearTimeout(this.pendingRetryTimer);
+              this.pendingRetryTimer = null;
+          }
+          if (this.nonceRefreshTimer) {
+              clearTimeout(this.nonceRefreshTimer);
+              this.nonceRefreshTimer = null;
+          }
           if (this.eventTracker) {
               this.eventTracker.destroy();
               this.eventTracker = null;
@@ -39189,6 +39380,7 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
       }
       play() { return this.corePlayer.play(); }
       pause() { return this.corePlayer.pause(); }
+      stopLoading() { return this.corePlayer.stopLoading(); }
       seek(t) { return this.corePlayer.seek(t); }
       getCurrentTime() { return this.corePlayer.getCurrentTime(); }
       getDuration() { return this.corePlayer.getDuration(); }