@guardvideo/player-sdk 3.3.0 → 3.5.0

package/dist/index.js

@@ -70,8 +70,19 @@ class WatchChunkAccumulator {
     }
 }
 
+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 = [];
@@ -79,6 +90,8 @@ class EventTracker {
         this.accumulator = new WatchChunkAccumulator();
         this.destroyed = false;
         this._onBeforeUnload = null;
+        this.flushBackoff = 0;
+        this.flushing = false;
         this.config = {
             endpoint: config.endpoint,
             tokenId: config.tokenId,
@@ -94,6 +107,12 @@ class EventTracker {
     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(),
@@ -117,7 +136,7 @@ class EventTracker {
         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) {
@@ -125,8 +144,14 @@ class EventTracker {
         }
         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;
@@ -141,6 +166,11 @@ class EventTracker {
     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;
@@ -186,8 +216,25 @@ class EventTracker {
                 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) {
@@ -403,6 +450,11 @@ class GuardVideoPlayer {
         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 = {
@@ -613,27 +665,34 @@ class GuardVideoPlayer {
     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);
@@ -643,12 +702,16 @@ class GuardVideoPlayer {
     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',
@@ -656,12 +719,19 @@ class GuardVideoPlayer {
                 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) {
@@ -669,19 +739,38 @@ class GuardVideoPlayer {
             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) {
@@ -721,8 +810,12 @@ class GuardVideoPlayer {
             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) {
@@ -730,10 +823,6 @@ class GuardVideoPlayer {
                         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');
-                        });
                     }
                 }
             },
@@ -745,6 +834,7 @@ class GuardVideoPlayer {
             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();
         });
@@ -760,18 +850,52 @@ class GuardVideoPlayer {
             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) {
@@ -781,7 +905,8 @@ class GuardVideoPlayer {
                         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...');
@@ -859,6 +984,10 @@ class GuardVideoPlayer {
     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;