@guardvideo/player-sdk 3.3.0 → 3.5.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,11 @@ 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._onRateChange = this.enforceMaxRate.bind(this);
           this.videoElement = videoElement;
           this.config = {
@@ -37235,27 +37287,34 @@ 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;
               }
               const challenge = await resp.json();
-              this.log('Challenge received, computing PBKDF2 response...');
+              this.log('Challenge received, computing PBKDF2 proof-of-work...');
               const encoder = new TextEncoder();
               const keyMaterial = await crypto.subtle.importKey('raw', encoder.encode(challenge.nonce), 'PBKDF2', false, ['deriveBits']);
-              const derivedBits = await crypto.subtle.deriveBits({
+              await crypto.subtle.deriveBits({
                   name: 'PBKDF2',
                   salt: encoder.encode(challenge.salt),
                   iterations: challenge.iterations,
                   hash: 'SHA-256',
               }, keyMaterial, challenge.keyLength * 8);
-              const hashArray = Array.from(new Uint8Array(derivedBits));
-              const hexResponse = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
-              this.log('Challenge response computed');
-              return hexResponse;
+              this.log('Challenge proof-of-work completed');
+              return { nonce: challenge.nonce };
           }
           catch (err) {
               this.log('Challenge computation failed (non-fatal):', err);
@@ -37265,12 +37324,16 @@ 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 challengeResponse = await this.solveChallenge(tokenId);
+              const challengeResult = await this.solveChallenge(tokenId);
               const url = this.config.apiBaseUrl + '/videos/playlist-session';
               const body = { tokenId };
-              if (challengeResponse) {
-                  body.challengeResponse = challengeResponse;
+              if (challengeResult) {
+                  body.challengeNonce = challengeResult.nonce;
               }
               const resp = await fetch(url, {
                   method: 'POST',
@@ -37278,12 +37341,19 @@ 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.scheduleNonceRefresh(data.expiresIn);
               return data.nonce;
           }
           catch (err) {
@@ -37291,19 +37361,38 @@ 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(() => {
+              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);
       }
       async initializePlayer() {
           if (!this.embedToken) {
@@ -37343,8 +37432,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) {
@@ -37352,10 +37445,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');
-                          });
                       }
                   }
               },
@@ -37367,6 +37456,7 @@ 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;
               if (this.config.autoplay)
                   this.play();
           });
@@ -37382,18 +37472,52 @@ 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 (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;
+                      setTimeout(() => 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');
+                  setTimeout(() => {
+                      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.refreshNonce().then(() => {
-                      setTimeout(() => this.hls?.startLoad(), 500);
+                      setTimeout(() => this.hls?.startLoad(), this.retryBackoff);
                   }).catch(() => {
-                      setTimeout(() => this.hls?.startLoad(), 1000);
+                      setTimeout(() => this.hls?.startLoad(), this.retryBackoff);
                   });
+                  this.retryBackoff = Math.min(this.retryBackoff * 1.5, this.MAX_BACKOFF);
                   return;
               }
               if (data.fatal) {
@@ -37403,7 +37527,8 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
                           if (this.embedToken?.forensicWatermark) {
                               this.refreshNonce().catch(() => { });
                           }
-                          setTimeout(() => this.hls?.startLoad(), 1000);
+                          setTimeout(() => 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...');
@@ -37481,6 +37606,10 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
       getState() { return this.state; }
       destroy() {
           this.log('Destroying player');
+          if (this.nonceRefreshTimer) {
+              clearTimeout(this.nonceRefreshTimer);
+              this.nonceRefreshTimer = null;
+          }
           if (this.eventTracker) {
               this.eventTracker.destroy();
               this.eventTracker = null;