@codenkay/video-nsgplayer-core 2.0.0 → 3.0.1

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 3.0.1
+
+- Permanent AES key path: dedicated key loader with **session circuit breaker**
+  (`keyProxyMaxFailures` default **2**). A Cloudflare-blocked BFF is not hammered
+  by hls.js retries (previously 9–10× `/hls-key` 502s).
+- After the circuit opens, the session uses AuthManager Bearer (or signed-query XHR) only.
+- Host apps with `AUTH_MODE=browser` should omit `keyProxyUrlBuilder` entirely.
+
+## 3.0.0
+
+### Major Changes
+
+- Fix minor issues
+
+## 2.0.1
+
+- Auto-wire `AuthManager.getAccessToken()` as default `streaming.getKeyAccessToken` so AES `enc.key` can load with Bearer when no BFF key proxy is configured.
+- When `keyProxyUrlBuilder` returns 401/403/502/CORS (e.g. Cloudflare-blocked BFF), automatically fall back to browser Bearer `enc.key` fetch.
+- On Bearer `enc.key` fetch network/CORS failure, fall back to signed-query XHR (CDN hosts).
+
 ## 2.0.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -39,6 +39,7 @@ __export(index_exports, {
   DEFAULT_THEME: () => DEFAULT_THEME,
   DEFAULT_WATERMARK: () => DEFAULT_WATERMARK,
   EventEmitter: () => EventEmitter,
+  KEY_PROXY_MAX_FAILURES: () => KEY_PROXY_MAX_FAILURES,
   PACKAGE_VERSION: () => PACKAGE_VERSION,
   PLAYBACK_RATES: () => PLAYBACK_RATES,
   PlaybackSourceManager: () => PlaybackSourceManager,
@@ -212,7 +213,7 @@ var AuthManager = class {
 
 // src/config/defaults.ts
 var PLAYBACK_RATES = [0.5, 0.75, 1, 1.25, 1.5, 2];
-var PACKAGE_VERSION = "0.1.8";
+var PACKAGE_VERSION = "3.0.1";
 var DEFAULT_PLAYER_BEHAVIOR = {
   autoplay: true,
   startMuted: true,
@@ -391,7 +392,8 @@ function mergePlayerConfig(partial) {
         ...partial?.streaming?.hls
       },
       keyProxyUrlBuilder: partial?.streaming?.keyProxyUrlBuilder,
-      getKeyAccessToken: partial?.streaming?.getKeyAccessToken
+      getKeyAccessToken: partial?.streaming?.getKeyAccessToken,
+      keyProxyMaxFailures: partial?.streaming?.keyProxyMaxFailures
     },
     logging: { ...DEFAULT_PLAYER_CONFIG.logging, ...partial?.logging },
     debug: { ...DEFAULT_PLAYER_CONFIG.debug, ...partial?.debug },
@@ -834,6 +836,7 @@ function seekToLiveEdge(media, options) {
 var import_hls = require("hls.js");
 var ENC_KEY_PATH_RE = /enc\.key$/i;
 var BUILTIN_LOADER_NAMES = /* @__PURE__ */ new Set(["XhrLoader", "FetchLoader"]);
+var KEY_PROXY_MAX_FAILURES = 2;
 function isEncryptionKeyUrl(rawUrl, baseOrigin = typeof location !== "undefined" ? location.origin : "http://localhost") {
   try {
     return ENC_KEY_PATH_RE.test(new URL(rawUrl, baseOrigin).pathname);
@@ -894,6 +897,20 @@ function createLoaderStats() {
     buffering: { start: 0, first: 0, end: 0 }
   };
 }
+function isProxyUpstreamBlocked(status, contentType, bodyHead, errorText) {
+  if (status === 0 || status === 502 || status === 503 || status === 504) {
+    return true;
+  }
+  if (status === 403 || status === 401) return true;
+  if (contentType?.includes("text/html")) return true;
+  if (/<!DOCTYPE|<html|Just a moment|Cloudflare|blocked/i.test(bodyHead)) {
+    return true;
+  }
+  if (errorText && /Cloudflare|HTML|DOCTYPE|blocked|502/i.test(errorText)) {
+    return true;
+  }
+  return false;
+}
 async function loadEncryptionKeyWithFetch(context, callbacks, accessToken, signal) {
   const stats = createLoaderStats();
   stats.loading.first = performance.now();
@@ -952,10 +969,122 @@ async function loadEncryptionKeyWithFetch(context, callbacks, accessToken, signa
     response
   );
 }
+async function loadEncryptionKeyEnterprise(context, callbacks, plan, signal, state) {
+  const stats = createLoaderStats();
+  stats.loading.first = performance.now();
+  const canTryProxy = Boolean(plan.proxyUrl) && !state.circuitOpen && state.proxyFailures < plan.maxProxyFailures;
+  if (canTryProxy && plan.proxyUrl) {
+    while (!state.circuitOpen && state.proxyFailures < plan.maxProxyFailures && !signal.aborted) {
+      state.proxyFailures += 1;
+      try {
+        const response = await fetch(plan.proxyUrl, {
+          method: "GET",
+          headers: { Accept: "*/*" },
+          credentials: "same-origin",
+          cache: "no-store",
+          signal
+        });
+        const contentType = response.headers.get("content-type");
+        const data = await response.arrayBuffer();
+        const head = new TextDecoder().decode(data.slice(0, 64));
+        if (response.ok && !isProxyUpstreamBlocked(response.status, contentType, head)) {
+          const end = performance.now();
+          stats.loading.end = end;
+          stats.loaded = data.byteLength;
+          stats.total = data.byteLength;
+          callbacks.onSuccess(
+            {
+              url: response.url || plan.proxyUrl,
+              data,
+              code: response.status
+            },
+            stats,
+            { ...context, url: plan.proxyUrl },
+            response
+          );
+          return "ok";
+        }
+        if (isProxyUpstreamBlocked(
+          response.status,
+          contentType,
+          head,
+          response.statusText
+        )) {
+          if (response.status === 502 || contentType?.includes("text/html") || /Cloudflare|DOCTYPE|blocked/i.test(head)) {
+            state.circuitOpen = true;
+            break;
+          }
+          continue;
+        }
+        callbacks.onError(
+          {
+            code: response.status,
+            text: `enc.key proxy HTTP ${response.status}`
+          },
+          { ...context, url: plan.proxyUrl },
+          response,
+          stats
+        );
+        return "ok";
+      } catch (error) {
+        if (error instanceof DOMException && error.name === "AbortError") {
+          callbacks.onError(
+            { code: 0, text: "enc.key proxy aborted/timeout" },
+            context,
+            null,
+            stats
+          );
+          return "ok";
+        }
+        state.circuitOpen = true;
+        break;
+      }
+    }
+    state.circuitOpen = true;
+  }
+  if (plan.accessToken) {
+    try {
+      await loadEncryptionKeyWithFetch(
+        { ...context, url: plan.signedKeyUrl },
+        callbacks,
+        plan.accessToken,
+        signal
+      );
+      return "ok";
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        callbacks.onError(
+          { code: 0, text: "enc.key fetch aborted/timeout" },
+          { ...context, url: plan.signedKeyUrl },
+          null,
+          stats
+        );
+        return "ok";
+      }
+      if (error instanceof TypeError || error instanceof Error && /Failed to fetch|NetworkError|CORS/i.test(error.message)) {
+        return "try_xhr";
+      }
+      callbacks.onError(
+        {
+          code: 0,
+          text: error instanceof Error ? error.message : "enc.key Bearer fetch failed"
+        },
+        { ...context, url: plan.signedKeyUrl },
+        null,
+        stats
+      );
+      return "ok";
+    }
+  }
+  return "try_xhr";
+}
 function createAuthParamsLoader(HlsClass, store, options = {}) {
   const BaseLoader = resolveBuiltinHlsLoader(HlsClass);
+  const maxProxyFailures = typeof options.keyProxyMaxFailures === "number" && options.keyProxyMaxFailures >= 0 ? options.keyProxyMaxFailures : KEY_PROXY_MAX_FAILURES;
+  const keyProxyState = { proxyFailures: 0, circuitOpen: false };
   return class AuthParamsLoader {
     constructor(config) {
+      this.context = null;
       this.keyAbort = null;
       this.inner = new BaseLoader(config);
       this.stats = this.inner.stats;
@@ -963,14 +1092,16 @@ function createAuthParamsLoader(HlsClass, store, options = {}) {
     abort() {
       this.keyAbort?.abort();
       this.keyAbort = null;
-      this.inner.abort?.();
+      this.inner.abort();
     }
     destroy() {
       this.keyAbort?.abort();
       this.keyAbort = null;
+      this.context = null;
       this.inner.destroy();
     }
     load(context, config, callbacks) {
+      this.context = context;
       if (!context.url) {
         this.inner.load(context, config, callbacks);
         return;
@@ -978,44 +1109,59 @@ function createAuthParamsLoader(HlsClass, store, options = {}) {
       try {
         const originalUrl = context.url;
         const isKey = isEncryptionKeyUrl(originalUrl);
-        const usingKeyProxy = Boolean(
-          isKey && options.keyProxyUrlBuilder && options.videoId
-        );
-        context.url = rewriteHlsRequestUrl(originalUrl, store, options);
-        if (usingKeyProxy) {
+        if (!isKey) {
+          if (store.hasParams()) {
+            context.url = rewriteHlsRequestUrl(originalUrl, store, {
+              ...options,
+              keyProxyUrlBuilder: void 0
+            });
+          }
           this.inner.load(context, config, callbacks);
           return;
         }
-        if (isKey && typeof options.getKeyAccessToken === "function") {
-          const accessToken = options.getKeyAccessToken() ?? null;
-          if (accessToken) {
-            this.keyAbort?.abort();
-            this.keyAbort = new AbortController();
-            const timeoutMs = typeof config?.timeout === "number" && config.timeout > 0 ? config.timeout : 2e4;
-            const timer = setTimeout(() => this.keyAbort?.abort(), timeoutMs);
-            void loadEncryptionKeyWithFetch(
-              context,
-              callbacks,
-              accessToken,
-              this.keyAbort.signal
-            ).catch((error) => {
-              const stats = createLoaderStats();
-              const aborted = error instanceof DOMException && error.name === "AbortError";
-              callbacks.onError(
-                {
-                  code: 0,
-                  text: aborted ? "enc.key fetch aborted/timeout" : error instanceof Error ? error.message : "enc.key fetch failed"
-                },
-                context,
-                null,
-                stats
-              );
-            }).finally(() => {
-              clearTimeout(timer);
-            });
-            return;
+        const signedKeyUrl = rewriteHlsRequestUrl(originalUrl, store, {
+          ...options,
+          keyProxyUrlBuilder: void 0
+        });
+        const proxyConfigured = Boolean(
+          options.keyProxyUrlBuilder && options.videoId
+        );
+        const proxyUrl = proxyConfigured && !keyProxyState.circuitOpen ? rewriteHlsRequestUrl(originalUrl, store, options) : null;
+        const accessToken = options.getKeyAccessToken?.() ?? null;
+        this.keyAbort?.abort();
+        this.keyAbort = new AbortController();
+        const timeoutMs = typeof config?.timeout === "number" && config.timeout > 0 ? config.timeout : 2e4;
+        const timer = setTimeout(() => this.keyAbort?.abort(), timeoutMs);
+        void loadEncryptionKeyEnterprise(
+          context,
+          callbacks,
+          {
+            proxyUrl,
+            signedKeyUrl,
+            accessToken,
+            maxProxyFailures
+          },
+          this.keyAbort.signal,
+          keyProxyState
+        ).then((result) => {
+          if (result === "try_xhr") {
+            context.url = signedKeyUrl;
+            this.inner.load(context, config, callbacks);
           }
-        }
+        }).catch((error) => {
+          callbacks.onError(
+            {
+              code: 0,
+              text: error instanceof Error ? error.message : "enc.key load failed"
+            },
+            context,
+            null,
+            createLoaderStats()
+          );
+        }).finally(() => {
+          clearTimeout(timer);
+        });
+        return;
       } catch {
       }
       this.inner.load(context, config, callbacks);
@@ -1085,7 +1231,8 @@ var HlsEngine = class {
     const loader = createAuthParamsLoader(Hls, authParams, {
       videoId,
       keyProxyUrlBuilder,
-      getKeyAccessToken
+      getKeyAccessToken,
+      keyProxyMaxFailures: this.options.keyProxyMaxFailures
     });
     this.hls = new Hls({
       enableWorker: hlsConfig.enableWorker,
@@ -1509,12 +1656,12 @@ function createVideoPlayer(options) {
         volume: config.player.volume,
         videoId: options.videoId,
         keyProxyUrlBuilder: config.streaming.keyProxyUrlBuilder,
-        // Optional: browser Bearer for Video API–origin enc.key (CORS-dependent).
-        // CDN keys use signed query via the auth loader (no Bearer) — same as
-        // segments. Apps can pass getKeyAccessToken or rely on keyProxyUrlBuilder.
-        // When unset, defaults to AuthManager token only if explicitly requested
-        // via streaming.getKeyAccessToken; otherwise query-signed XHR.
-        getKeyAccessToken: config.streaming.getKeyAccessToken,
+        // Enterprise AES key auth:
+        // 1) keyProxyUrlBuilder (same-origin BFF) when configured — max 2 failures
+        // 2) else getKeyAccessToken / AuthManager Bearer via browser fetch
+        // 3) else signed query + XHR (CDN hosts)
+        getKeyAccessToken: config.streaming.getKeyAccessToken ?? (() => authManager.getAccessToken()),
+        keyProxyMaxFailures: config.streaming.keyProxyMaxFailures,
         hlsConfig: config.streaming.hls,
         logger,
         callbacks: {
@@ -1832,7 +1979,8 @@ function createVideoPlayer(options) {
           engine: "hls",
           hls: { ...config.streaming.hls, ...partial?.streaming?.hls },
           keyProxyUrlBuilder: partial?.streaming?.keyProxyUrlBuilder ?? config.streaming.keyProxyUrlBuilder,
-          getKeyAccessToken: partial?.streaming?.getKeyAccessToken ?? config.streaming.getKeyAccessToken
+          getKeyAccessToken: partial?.streaming?.getKeyAccessToken ?? config.streaming.getKeyAccessToken ?? (() => authManager.getAccessToken()),
+          keyProxyMaxFailures: partial?.streaming?.keyProxyMaxFailures ?? config.streaming.keyProxyMaxFailures
         },
         logging: { ...config.logging, ...partial?.logging },
         debug: { ...config.debug, ...partial?.debug },
@@ -1864,6 +2012,7 @@ function createVideoPlayer(options) {
   DEFAULT_THEME,
   DEFAULT_WATERMARK,
   EventEmitter,
+  KEY_PROXY_MAX_FAILURES,
   PACKAGE_VERSION,
   PLAYBACK_RATES,
   PlaybackSourceManager,