@guardvideo/player-sdk 3.2.0 → 3.3.0

package/dist/vanilla/guardvideo-player.js

@@ -37023,6 +37023,8 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
           this.eventTracker = null;
           this.sdkFingerprint = null;
           this._onSecurityEvent = null;
+          this.playlistNonce = null;
+          this.nonceRefreshInProgress = false;
           this._onRateChange = this.enforceMaxRate.bind(this);
           this.videoElement = videoElement;
           this.config = {
@@ -37122,6 +37124,10 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
               this.embedToken = await this.fetchEmbedToken();
               this.log('Embed token received', this.embedToken);
               await this.fetchAndApplyWatermark();
+              if (this.embedToken.forensicWatermark) {
+                  this.playlistNonce = await this.acquireNonce(this.embedToken.tokenId);
+                  this.log('Initial playlist nonce: ' + (this.playlistNonce ? 'acquired' : 'skipped'));
+              }
               await this.initializePlayer();
           }
           catch (err) {
@@ -37226,6 +37232,79 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
           }
           return await response.json();
       }
+      async solveChallenge(tokenId) {
+          if (!this.config.apiBaseUrl)
+              return undefined;
+          try {
+              const url = this.config.apiBaseUrl + '/videos/challenge/' + encodeURIComponent(tokenId);
+              const resp = await fetch(url, { credentials: 'omit' });
+              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...');
+              const encoder = new TextEncoder();
+              const keyMaterial = await crypto.subtle.importKey('raw', encoder.encode(challenge.nonce), 'PBKDF2', false, ['deriveBits']);
+              const derivedBits = 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;
+          }
+          catch (err) {
+              this.log('Challenge computation failed (non-fatal):', err);
+              return undefined;
+          }
+      }
+      async acquireNonce(tokenId) {
+          if (!this.config.apiBaseUrl)
+              return null;
+          try {
+              const challengeResponse = await this.solveChallenge(tokenId);
+              const url = this.config.apiBaseUrl + '/videos/playlist-session';
+              const body = { tokenId };
+              if (challengeResponse) {
+                  body.challengeResponse = challengeResponse;
+              }
+              const resp = await fetch(url, {
+                  method: 'POST',
+                  headers: { 'Content-Type': 'application/json' },
+                  body: JSON.stringify(body),
+                  credentials: 'omit',
+              });
+              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');
+              return data.nonce;
+          }
+          catch (err) {
+              this.log('Nonce acquisition error (non-fatal):', err);
+              return null;
+          }
+      }
+      async refreshNonce() {
+          if (this.nonceRefreshInProgress)
+              return;
+          if (!this.embedToken)
+              return;
+          this.nonceRefreshInProgress = true;
+          try {
+              const nonce = await this.acquireNonce(this.embedToken.tokenId);
+              this.playlistNonce = nonce;
+          }
+          finally {
+              this.nonceRefreshInProgress = false;
+          }
+      }
       async initializePlayer() {
           if (!this.embedToken) {
               throw new Error('No embed token available');
@@ -37258,10 +37337,28 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
       }
       initializeHls(playerUrl) {
           this.log('Using HLS.js for adaptive streaming');
+          const self = this;
           this.hls = new Hls({
               debug: this.config.debug,
               enableWorker: true,
               lowLatencyMode: false,
+              liveSyncDurationCount: 3,
+              manifestLoadingMaxRetry: 6,
+              levelLoadingMaxRetry: 6,
+              xhrSetup(xhr, url) {
+                  if (url.includes('/watermark-stream/') && url.includes('.m3u8')) {
+                      if (self.playlistNonce) {
+                          const separator = url.includes('?') ? '&' : '?';
+                          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');
+                          });
+                      }
+                  }
+              },
               ...this.config.hlsConfig,
           });
           this.hls.loadSource(playerUrl);
@@ -37288,10 +37385,24 @@ Schedule: ${scheduleItems.map(seg => segmentToString(seg))} pos: ${this.timeline
           });
           this.hls.on(Hls.Events.ERROR, (_event, data) => {
               this.error('HLS Error', data);
+              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);
+                  }).catch(() => {
+                      setTimeout(() => this.hls?.startLoad(), 1000);
+                  });
+                  return;
+              }
               if (data.fatal) {
                   switch (data.type) {
                       case Hls.ErrorTypes.NETWORK_ERROR:
                           this.error('Network error, attempting recovery...');
+                          if (this.embedToken?.forensicWatermark) {
+                              this.refreshNonce().catch(() => { });
+                          }
                           setTimeout(() => this.hls?.startLoad(), 1000);
                           break;
                       case Hls.ErrorTypes.MEDIA_ERROR: