@titan-os/sdk 1.7.0 → 1.7.2

package/dist/esm/sdk.js

@@ -112,6 +112,17 @@ class LogSubscriptionManager {
     if (this.logBuffer.length > this.maxBufferSize) {
       this.logBuffer.shift();
     }
+    const isGatewayEntry = entry.metadata?.source === "Gateway" || entry.metadata?.tunneled === true;
+    if (isGatewayEntry && entry.level === "error") {
+      const callerInfo = entry.metadata?.caller || "[Gateway]";
+      const consoleArgs = formatConsoleOutput(
+        entry.module,
+        entry.message,
+        entry.args || [],
+        callerInfo
+      );
+      outputToConsole("error", consoleArgs);
+    }
     this.subscriptions.forEach((subscription) => {
       if (this.shouldNotifySubscription(subscription, entry)) {
         try {
@@ -183,9 +194,28 @@ class LogSubscriptionManager {
     return [...filtered];
   }
 }
+function formatConsoleOutput(module, message, args, callerInfo) {
+  const prefix = `[TitanSDK][${module}]`;
+  return [`${prefix} ${message}`, ...args, "\n", callerInfo];
+}
+function outputToConsole(level, consoleArgs) {
+  switch (level) {
+    case "debug":
+      console.debug(...consoleArgs);
+      break;
+    case "info":
+      console.info(...consoleArgs);
+      break;
+    case "warn":
+      console.warn(...consoleArgs);
+      break;
+    case "error":
+      console.error(...consoleArgs);
+      break;
+  }
+}
 const globalLogManager = new LogSubscriptionManager();
 function createEnhancedLogger(module) {
-  const prefix = `[TitanSDK] [${module}]`;
   const getStackDetails = (callerInfo) => {
     let fnName = "";
     let fnPath = "";
@@ -248,28 +278,15 @@ function createEnhancedLogger(module) {
       }
     };
     globalLogManager.addLogEntry(entry);
-    const shouldLogToConsole = globalLogManager.isDebugMode() || level === "warn" || level === "error";
+    const shouldLogToConsole = globalLogManager.isDebugMode() || level === "error";
     if (shouldLogToConsole) {
-      const consoleArgs = [
-        `${prefix} ${message}`,
-        ...args,
-        "\n",
+      const consoleArgs = formatConsoleOutput(
+        module,
+        message,
+        args,
         formattedCallerInfo
-      ];
-      switch (level) {
-        case "debug":
-          console.debug(...consoleArgs);
-          break;
-        case "info":
-          console.info(...consoleArgs);
-          break;
-        case "warn":
-          console.warn(...consoleArgs);
-          break;
-        case "error":
-          console.error(...consoleArgs);
-          break;
-      }
+      );
+      outputToConsole(level, consoleArgs);
     }
   };
   return {
@@ -914,14 +931,17 @@ class BaseBridge {
       this.initReject = reject;
       log$u.debug("bridge: starting initialization process");
       window.addEventListener("message", this.handleMessage.bind(this));
+      let isResolved = false;
       const handleIframeLoad = () => {
-        if (this.aborted) return;
+        if (this.aborted || isResolved) return;
+        isResolved = true;
         this.isInitialized = true;
         log$u.debug("bridge initialized successfully");
         resolve(true);
       };
       const handleIframeError = () => {
-        if (this.aborted) return;
+        if (this.aborted || isResolved) return;
+        isResolved = true;
         log$u.error("Bridge iframe failed to load or initialize.");
         this.isInitialized = false;
         reject(new Error("Bridge iframe failed to load or initialize."));
@@ -929,7 +949,17 @@ class BaseBridge {
       (async () => {
         try {
           await this.setupIframe(handleIframeLoad, handleIframeError);
+          if (!isResolved) {
+            isResolved = true;
+            log$u.warn(
+              "Bridge initialization timeout - setupIframe completed but LAUNCHER_READY not received"
+            );
+            this.isInitialized = false;
+            resolve(false);
+          }
         } catch (error) {
+          if (isResolved) return;
+          isResolved = true;
           log$u.error("Failed to setup iframe:", error);
           this.isInitialized = false;
           reject(error);
@@ -1329,10 +1359,29 @@ __publicField(_CSPDetector, "violations", []);
 let CSPDetector = _CSPDetector;
 const log$s = getLogger("EnhancedBridge");
 function isBridgeCspViolation(violation, src) {
-  if (violation.directive !== "frame-src" || !violation.blockedURI || !src) {
+  const relevantDirectives = ["frame-src", "child-src", "connect-src"];
+  if (!relevantDirectives.includes(violation.directive) || !violation.blockedURI || !src) {
     return false;
   }
-  return src.includes(violation.blockedURI) || violation.blockedURI.includes(src);
+  const blockedURI = violation.blockedURI;
+  const normalizeUrl = (url) => {
+    return url.replace(/\/+$/, "").toLowerCase();
+  };
+  const normalizedBlocked = normalizeUrl(blockedURI);
+  const normalizedSrc = normalizeUrl(src);
+  const getDomain = (url) => {
+    try {
+      const urlObj = new URL(url);
+      return urlObj.hostname;
+    } catch {
+      const match = url.match(/^(?:https?:\/\/)?([^\/]+)/);
+      return match ? match[1] : "";
+    }
+  };
+  const blockedDomain = getDomain(blockedURI);
+  const srcDomain = getDomain(src);
+  const isGatewayRelated = normalizedSrc.includes(normalizedBlocked) || normalizedBlocked.includes(normalizedSrc) || blockedDomain && srcDomain && blockedDomain === srcDomain || blockedURI.includes("titanos.tv") && src.includes("titanos.tv") || blockedURI.includes("localhost") && src.includes("localhost");
+  return isGatewayRelated;
 }
 class EnhancedBaseBridge extends BaseBridge {
   constructor(config) {
@@ -1345,20 +1394,42 @@ class EnhancedBaseBridge extends BaseBridge {
       cspViolations: []
     });
     __publicField(this, "cspUnsubscribe");
+    __publicField(this, "cspViolationDetected", false);
+    __publicField(this, "cspViolationPromise");
+    __publicField(this, "cspViolationResolver", null);
     this.bridgeHealthStatus.gatewayUrl = this.src;
+    this.cspViolationPromise = new Promise((resolve) => {
+      this.cspViolationResolver = resolve;
+    });
     this.setupCspViolationListener();
   }
   setupCspViolationListener() {
     this.cspUnsubscribe = CSPDetector.onViolation(
       (violation) => {
+        log$s.debug("CSP violation received in EnhancedBaseBridge:", {
+          directive: violation.directive,
+          blockedURI: violation.blockedURI,
+          gatewayUrl: this.src,
+          isBridgeViolation: isBridgeCspViolation(violation, this.src)
+        });
         if (isBridgeCspViolation(violation, this.src)) {
+          const violationString = `${violation.directive}: ${violation.blockedURI || "unknown"}`;
+          if (!this.bridgeHealthStatus.cspViolations.includes(violationString)) {
+            this.bridgeHealthStatus.cspViolations.push(violationString);
+          }
           log$s.warn("CSP violation detected for bridge:", {
             directive: violation.directive,
             blockedURI: violation.blockedURI,
             gatewayUrl: this.src
           });
           this.bridgeHealthStatus.cspBlocked = true;
-          this.bridgeHealthStatus.lastError = `CSP blocked: ${violation.directive}`;
+          this.bridgeHealthStatus.lastError = `CSP ${violation.directive} blocked: ${violation.blockedURI || "unknown"}`;
+          if (!this.cspViolationDetected && this.cspViolationResolver) {
+            this.cspViolationDetected = true;
+            log$s.debug("Resolving CSP violation Promise");
+            this.cspViolationResolver();
+            this.cspViolationResolver = null;
+          }
         }
       }
     );
@@ -1392,6 +1463,10 @@ class EnhancedBaseBridge extends BaseBridge {
       this.cspUnsubscribe();
       this.cspUnsubscribe = void 0;
     }
+    this.cspViolationDetected = false;
+    this.cspViolationPromise = new Promise((resolve) => {
+      this.cspViolationResolver = resolve;
+    });
     this.bridgeHealthStatus = {
       connected: false,
       cspBlocked: false,
@@ -1451,6 +1526,50 @@ class EnhancedBaseBridge extends BaseBridge {
       error: health.lastError
     };
   }
+  /**
+   * Waits for bridge initialization attempt to complete (success or failure).
+   * This method resolves when the bridge has finished attempting to initialize,
+   * allowing callers to check the initialization status without relying on timeouts.
+   */
+  async waitForInitializationAttempt() {
+    if (this.isConnected()) {
+      log$s.debug("Bridge already initialized, no need to wait");
+      return;
+    }
+    const bridge = this;
+    if (bridge.initializationPromise) {
+      log$s.debug("Bridge initialization in progress, waiting for completion...");
+      try {
+        await bridge.initializationPromise;
+        log$s.debug("Bridge initialization attempt completed");
+      } catch {
+        log$s.debug("Bridge initialization attempt completed (with error)");
+      }
+    } else {
+      log$s.debug(
+        "No bridge initialization in progress, starting new attempt..."
+      );
+      try {
+        await this.initialize();
+        log$s.debug("Bridge initialization attempt completed");
+      } catch {
+        log$s.debug("Bridge initialization attempt completed (with error)");
+      }
+    }
+    if (this.bridgeHealthStatus.iframeCreated && !this.isConnected()) {
+      if (this.cspViolationDetected || this.bridgeHealthStatus.cspBlocked) {
+        log$s.debug("CSP violation already detected, no need to wait");
+      } else {
+        log$s.debug(
+          "Iframe created but connection not established, waiting for CSP violation detection..."
+        );
+        await this.cspViolationPromise;
+        log$s.debug(
+          "CSP violation detection completed (or connection established)"
+        );
+      }
+    }
+  }
 }
 class VestelBridge extends EnhancedBaseBridge {
   constructor(config) {
@@ -3884,357 +4003,721 @@ function requireLzString() {
   return lzString.exports;
 }
 var lzStringExports = requireLzString();
-const VERSION = "1.7.0";
-const log$l = getLogger("TVPlatform");
-class TVPlatform extends BasePlatform {
-  // 7 days
-  constructor(config, bridge) {
-    super(config);
-    __publicField(this, "DEFAULT_DEVICE_INFO", {});
-    __publicField(this, "bridge");
-    __publicField(this, "isInitialized", false);
-    __publicField(this, "CACHE_KEY", "titansdk");
-    __publicField(this, "CACHE_EXPIRY", 7 * 24 * 60 * 60 * 1e3);
-    if (bridge) {
-      this.bridge = bridge;
-    } else {
-      const bridgeConfig = {
-        gatewayUrl: this.config.gatewayUrl
-      };
-      this.bridge = new EnhancedBaseBridge(bridgeConfig);
-    }
-    this.initializeBridgeSafely();
+const VERSION = "1.7.2";
+const logger$2 = getLogger("RollbarClient");
+const IGNORED_ERROR_PATTERNS = [
+  "chrome://userjs/",
+  "chrome-extension://",
+  "moz-extension://",
+  "getJWTString",
+  "getjwtstring",
+  "user.js",
+  "userscript",
+  "tampermonkey",
+  "greasemonkey",
+  "can't find variable getjwtstring",
+  "referenceerror: can't find variable: getjwtstring",
+  "unexpected end of json input",
+  "jsonparse"
+];
+class RollbarClient {
+  constructor() {
+    __publicField(this, "rollbar", null);
+    __publicField(this, "config", null);
+    __publicField(this, "windowWrapper", new WindowWrapper());
   }
-  async initializeBridgeSafely() {
-    try {
-      const success = await this.bridge.initialize();
-      if (success) {
-        this.isInitialized = true;
-      }
-    } catch (error) {
-      log$l.warn("Bridge initialization failed:", error);
-    }
-    this.waitReadyResolver(true);
+  isSDKError(error) {
+    return error instanceof SDKError || error instanceof Error && error.name === "SDKError";
   }
-  getFromLocalStorage() {
-    try {
-      if (typeof localStorage === "undefined") {
-        return null;
-      }
-      if (!localStorage.getItem) {
-        return null;
-      }
-      const cached = localStorage.getItem(this.CACHE_KEY);
-      if (!cached) {
-        return null;
-      }
-      const parsed = JSON.parse(cached);
-      if (Date.now() - parsed.timestamp > this.CACHE_EXPIRY || parsed.lastVersion !== VERSION) {
-        localStorage.removeItem(this.CACHE_KEY);
-        return null;
-      }
-      log$l.debug("Device info loaded from localStorage cache");
-      return parsed;
-    } catch (error) {
-      log$l.warn("Failed to load device info from localStorage:", error);
-      return null;
+  initialize(config) {
+    if (!config.enabled || !config.accessToken) {
+      logger$2.warn("Rollbar not initialized - disabled or missing access token");
+      return;
     }
-  }
-  getFromURL() {
     try {
-      const urlParams = new URLSearchParams(window.location.search);
-      const titansdkParam = urlParams.get("titandata");
-      if (!titansdkParam) {
-        return null;
-      }
-      let decoded = null;
-      const windowWrapper2 = new WindowWrapper();
-      try {
-        decoded = lzStringExports.decompressFromEncodedURIComponent(titansdkParam);
-        if (decoded) {
-          log$l.debug("Device info loaded from URL parameter (lz-string)");
-        }
-      } catch (lzError) {
-        log$l.debug("lz-string decompression failed, trying base64");
-      }
-      if (!decoded) {
-        try {
-          const atobFunc = windowWrapper2.get("atob");
-          if (atobFunc) {
-            const urlDecoded = decodeURIComponent(titansdkParam);
-            decoded = atobFunc(urlDecoded);
-            log$l.debug("Device info loaded from URL parameter (base64)");
-          } else {
-            log$l.warn("atob function not available");
-            return null;
+      this.config = config;
+      this.rollbar = new Rollbar({
+        accessToken: config.accessToken,
+        environment: config.environment || getEnvironment(),
+        captureUncaught: true,
+        captureUnhandledRejections: true,
+        verbose: false,
+        reportLevel: "error",
+        captureIp: false,
+        captureUsername: false,
+        captureEmail: false,
+        maxItems: 100,
+        itemsPerMinute: 60,
+        captureLambdaTimeouts: false,
+        endpoint: `${getLogsDomain()}/logs/`,
+        autoInstrument: {
+          network: false,
+          log: false,
+          dom: false,
+          navigation: false,
+          connectivity: false
+        },
+        payload: {
+          client: {
+            javascript: {
+              code_version: "unknown",
+              source_map_enabled: true
+            }
           }
-        } catch (base64Error) {
-          log$l.warn("Both lz-string and base64 decoding failed");
-          return null;
+        },
+        transform: (payload) => {
+          if (payload.context) {
+            payload.context = `hephaestus-${payload.context}`;
+          }
+        },
+        checkIgnore: (_isUncaught, args, _payload) => {
+          const error = args[0];
+          const errorMessage = typeof error === "string" ? error : error?.message;
+          const errorStack = typeof error === "object" && error ? error.stack : "";
+          const errorString = String(error).toLowerCase();
+          const ignoredPatterns = IGNORED_ERROR_PATTERNS;
+          return ignoredPatterns.some(
+            (pattern) => errorMessage?.toLowerCase().includes(pattern.toLowerCase()) || errorStack?.toLowerCase().includes(pattern.toLowerCase()) || errorString.includes(pattern.toLowerCase())
+          );
         }
-      }
-      if (!decoded) {
-        log$l.warn("Failed to decode URL parameter");
-        return null;
-      }
-      const parsed = JSON.parse(decoded);
-      return parsed;
+      });
+      this.setupGlobalErrorHandlers();
+      logger$2.info("Rollbar initialized successfully", {
+        environment: config.environment
+      });
     } catch (error) {
-      log$l.warn("Failed to load device info from URL parameter:", error);
-      return null;
+      logger$2.error("Failed to initialize Rollbar", { error, config });
     }
   }
-  saveToLocalStorage(data) {
-    try {
-      if (typeof localStorage === "undefined") {
-        return;
-      }
-      if (!data || !data.deviceId || !data.brand || !data.model) {
-        log$l.warn("Skipping cache save - invalid or empty device info");
-        return;
-      }
-      const cacheData = {
-        data,
-        timestamp: Date.now(),
-        lastVersion: VERSION
-      };
-      localStorage.setItem(this.CACHE_KEY, JSON.stringify(cacheData));
-      log$l.debug("Device info saved to localStorage cache");
-    } catch (error) {
-      log$l.warn("Failed to save device info to localStorage:", error);
-    }
+  shouldIgnoreError(error) {
+    if (!error) return true;
+    const errorMessage = typeof error === "string" ? error : error.message || "";
+    const errorStack = typeof error === "object" ? error.stack || "" : "";
+    const errorString = String(error).toLowerCase();
+    const ignoredPatterns = IGNORED_ERROR_PATTERNS;
+    return ignoredPatterns.some(
+      (pattern) => errorMessage?.toLowerCase().includes(pattern.toLowerCase()) || errorStack?.toLowerCase().includes(pattern.toLowerCase()) || errorString.includes(pattern.toLowerCase())
+    );
   }
-  async getBaseDeviceInfo() {
-    const urlData = this.getFromURL();
-    if (urlData) {
-      this.saveToLocalStorage(urlData);
-      this.waitReadyResolver(true);
-      return {
-        deviceInfo: urlData,
-        tts: DEFAULT_TTS_SETTINGS,
-        tm: DEFAULT_TM_SETTINGS
-      };
+  async reportError(error, additionalData, severity = "error") {
+    if (!this.rollbar || !this.config?.enabled || !error) {
+      return Promise.resolve(null);
     }
-    if (this.config.useCache !== false) {
-      const localStorageData = this.getFromLocalStorage();
-      if (localStorageData) {
-        this.waitReadyResolver(true);
-        return {
-          deviceInfo: localStorageData.data,
-          tts: DEFAULT_TTS_SETTINGS,
-          tm: DEFAULT_TM_SETTINGS
-        };
-      }
-    } else if (this.config.debug) {
-      log$l.debug("Debug mode: skipping cache, fetching fresh data from iframe");
+    if (!this.isSDKError(error)) {
+      return Promise.resolve(null);
     }
-    try {
-      await this.waitReady;
-      return await this.bridge.executeWithFallback(
-        async () => {
-          const deviceInfo = await this.bridge.getDeviceInfo();
-          if (!deviceInfo) {
-            throw new Error("Failed to get device info");
-          }
-          if (deviceInfo.deviceInfo) {
-            this.saveToLocalStorage(deviceInfo.deviceInfo);
-          }
-          return deviceInfo;
-        },
-        async () => {
-          log$l.warn("Bridge unavailable, returning fallback device info");
-          const fallbackData = {
-            deviceInfo: null,
-            tts: DEFAULT_TTS_SETTINGS,
-            tm: DEFAULT_TM_SETTINGS
+    if (this.shouldIgnoreError(error)) {
+      return Promise.resolve(null);
+    }
+    return new Promise((resolve) => {
+      this.getDeviceContext().then((deviceContext) => {
+        try {
+          const allLogs = LogManager.getHistory().filter(
+            (log2) => !log2.module.includes("RollbarClient") && !log2.message.includes("Rollbar") && log2.level !== "debug"
+          ).slice(-20);
+          const logsString = allLogs.map(
+            (log2) => `[${log2.timestamp}] ${log2.module}: ${log2.message}${log2.args && log2.args.length > 0 ? "\n  Args: " + JSON.stringify(log2.args) : ""}`
+          ).join("\n");
+          const context = {
+            logs: logsString,
+            component: additionalData?.component || "SDK",
+            operation: additionalData?.operation,
+            requestId: additionalData?.requestId,
+            timestamp: Date.now(),
+            url: typeof window !== "undefined" ? window.location?.href : void 0,
+            userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "unknown",
+            sessionId: this.generateSessionId(),
+            errorStack: typeof error === "object" ? error.stack : void 0,
+            version: typeof window !== "undefined" ? this.windowWrapper.get("TitanSDK")?.VERSION || "unknown" : "unknown",
+            ...deviceContext,
+            ...additionalData
           };
-          return fallbackData;
+          const rollbarMethod = severity === "critical" ? "critical" : "error";
+          const errorType = severity === "critical" ? "critical_error_with_logs" : "error_with_logs";
+          this.rollbar?.[rollbarMethod](
+            error,
+            {
+              custom: {
+                type: errorType,
+                context,
+                logCount: allLogs.length
+              }
+            },
+            (err, data) => {
+              if (err) {
+                if (!this.shouldIgnoreError(err)) {
+                  logger$2.error(
+                    `Failed to send ${severity} error to Rollbar`,
+                    {
+                      error: err,
+                      originalError: error
+                    }
+                  );
+                }
+                resolve(null);
+              } else {
+                const rollbarId = data ? data.uuid || data.result?.uuid || null : null;
+                logger$2.info(
+                  `${severity === "critical" ? "Critical error" : "Error"} sent to Rollbar`,
+                  {
+                    message: typeof error === "string" ? error : error?.message || "Unknown error",
+                    component: context.component,
+                    rollbarId,
+                    logCount: allLogs.length
+                  }
+                );
+                resolve(rollbarId);
+              }
+            }
+          );
+        } catch (rollbarError) {
+          logger$2.error(`Failed to send ${severity} error to Rollbar`, {
+            error: rollbarError,
+            originalError: error
+          });
+          resolve(null);
         }
-      );
+      }).catch((deviceError) => {
+        logger$2.error(`Failed to get device context for ${severity} error`, {
+          error: deviceError
+        });
+        resolve(null);
+      });
+    });
+  }
+  collectSDKUsage(functionName, result, success, component) {
+    if (!this.rollbar || !this.config?.enabled) return;
+    try {
+      const logLevel = success ? "info" : "warning";
+      this.rollbar[logLevel](`SDK function execution: ${functionName}`, {
+        custom: {
+          type: "sdk_function_execution",
+          functionName,
+          success,
+          component,
+          result: success ? result : void 0,
+          error: !success ? result : void 0,
+          timestamp: Date.now(),
+          url: typeof window !== "undefined" ? window.location?.href : void 0
+        }
+      });
+      logger$2.info("SDK function execution logged", {
+        functionName,
+        success,
+        component
+      });
     } catch (error) {
-      log$l.warn("Failed to get device info from bridge:", error);
+      logger$2.error("Failed to log SDK function execution", {
+        error,
+        functionName,
+        component
+      });
+    }
+  }
+  generateSessionId() {
+    return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  async getDeviceContext() {
+    try {
+      if (window?.TitanSDK) {
+        try {
+          const deviceInfo = await window?.TitanSDK?.deviceInfo?.getDeviceInfo?.();
+          return {
+            deviceInfo: deviceInfo ? JSON.stringify(deviceInfo) : "unavailable"
+          };
+        } catch (sdkError) {
+        }
+      }
       return {
-        deviceInfo: null,
-        tts: DEFAULT_TTS_SETTINGS,
-        tm: DEFAULT_TM_SETTINGS
+        deviceInfo: `OS: ${navigator?.platform || "unknown"}, Browser: ${this.detectBrowserEngine()}, Storage: ${"localStorage" in (window || {})}`
       };
+    } catch (error) {
+      return {};
     }
   }
-  isTV() {
-    return typeof window !== "undefined" && (navigator.userAgent.includes("TV") || navigator.userAgent.includes("SmartTV") || navigator.userAgent.includes("SMART-TV") || window.location.href.includes("file://"));
+  detectBrowserEngine() {
+    if (typeof navigator === "undefined") return "unknown";
+    const userAgent = navigator.userAgent;
+    if (userAgent.includes("Chrome")) return "Blink";
+    if (userAgent.includes("Firefox")) return "Gecko";
+    if (userAgent.includes("Safari") && !userAgent.includes("Chrome"))
+      return "WebKit";
+    if (userAgent.includes("Edge")) return "EdgeHTML";
+    return "unknown";
   }
-}
-const oipfWindow = new WindowWrapper();
-const windowStorage = new WindowWrapper();
-function detectStreamingSupport() {
-  const video = document.createElement("video");
-  if (!!video.canPlayType && typeof video.canPlayType === "function") {
-    return {
-      supportAppleHLS: video.canPlayType("application/vnd.apple.mpegURL") !== "" || video.canPlayType("audio/mpegurl") !== "",
-      supportMSSmoothStreaming: video.canPlayType("application/vnd.ms-sstr+xml") !== "",
-      supportMSSInitiator: video.canPlayType("application/vnd.ms-playready.initiator+xml") !== "",
-      supportMPEG_DASH: video.canPlayType("application/dash+xml") !== "" || "unknown"
+  setupGlobalErrorHandlers() {
+    if (typeof window === "undefined") return;
+    const originalConsoleError = console.error;
+    console.error = (...args) => {
+      originalConsoleError.apply(console, args);
+      const errorArg = args.find(
+        (arg) => arg instanceof Error || typeof arg === "string" && arg.includes("Error")
+      );
+      if (errorArg && this.isSDKError(errorArg) && !this.shouldIgnoreError(errorArg)) {
+        this.reportError(errorArg, {
+          component: "SDK",
+          operation: "console.error"
+        });
+      }
     };
+    if (typeof window !== "undefined") {
+      window.addEventListener("error", (event) => {
+        if (this.isSDKError(event.error) && !this.shouldIgnoreError(event.error)) {
+          this.reportError(event.error || event.message, {
+            component: "SDK",
+            operation: "window.onerror"
+          });
+        }
+      });
+      window.addEventListener("unhandledrejection", (event) => {
+        if (this.isSDKError(event.reason) && !this.shouldIgnoreError(event.reason)) {
+          this.reportError(event.reason, {
+            component: "SDK",
+            operation: "unhandledrejection"
+          });
+        }
+      });
+    }
   }
-  return {
-    supportAppleHLS: false,
-    supportMSSmoothStreaming: false,
-    supportMSSInitiator: false,
-    supportMPEG_DASH: "unknown"
-  };
-}
-function detect3DUHDSupport() {
-  try {
-    const sysinfoElement = document.createElement("object");
-    sysinfoElement.setAttribute("id", "sysinfo");
-    sysinfoElement.setAttribute("type", "systeminfoobject");
-    document.body.appendChild(sysinfoElement);
-    const sysinfo = sysinfoElement;
-    const result = {
-      support3d: Boolean(sysinfo.has3D),
-      supportUHD: sysinfo.panelinfo?.toLowerCase() === "3840x2160"
-    };
-    return { ...result, supportFHD: true };
-  } catch (error) {
-    return {
-      support3d: false,
-      supportUHD: false,
-      supportFHD: true
-    };
+  isInitialized() {
+    return this.rollbar !== null && this.config?.enabled === true;
   }
 }
-function detectOIPFSupport() {
-  try {
-    if (oipfWindow.get("oipfObjectFactory") !== void 0) {
-      return { supportOIPF: true };
+const rollbarClient = new RollbarClient();
+const lastReportedAtByCode = {};
+const REPORT_THROTTLE_MS = 5e3;
+function redactAndTrimContext(context) {
+  const result = {};
+  const SENSITIVE_KEYS = /jwt|token|authorization|cookie|password|secret/i;
+  const trimValue = (value) => {
+    if (typeof value === "string") {
+      return value.length > 500 ? `${value.slice(0, 500)}…` : value;
+    }
+    if (Array.isArray(value)) {
+      const limited = value.slice(-50);
+      return limited.map(
+        (v) => typeof v === "string" && v.length > 500 ? `${v.slice(0, 500)}…` : v
+      );
     }
-    const testObject = document.createElement("object");
-    testObject.type = "application/oipfdrmagent";
-    const agent = testObject;
-    if (typeof agent.sendDRMMessage === "function") {
-      return { supportOIPF: true };
+    return value;
+  };
+  Object.keys(context).forEach((key) => {
+    const raw = context[key];
+    if (SENSITIVE_KEYS.test(key)) {
+      result[key] = "[REDACTED]";
+    } else {
+      result[key] = trimValue(raw);
     }
-    return { supportOIPF: false };
-  } catch (e) {
-    return { supportOIPF: false };
-  }
+  });
+  return result;
 }
-function detectBrowserCapabilities() {
+function reportCriticalCode(code, component, operation, context = {}) {
   try {
-    const navigatorWrapper = new WindowWrapper();
-    const navigatorObj = navigatorWrapper.get("navigator");
-    const hasRequestMediaKeySystemAccess = navigatorObj !== void 0 && typeof navigatorObj.requestMediaKeySystemAccess === "function";
-    const hasMSMediaKeys = windowStorage.has("MSMediaKeys");
-    return {
-      supportWebSocket: windowStorage.has("WebSocket"),
-      supportEME: hasRequestMediaKeySystemAccess || hasMSMediaKeys,
-      hasStorage: windowStorage.has("localStorage") && windowStorage.has("sessionStorage")
-    };
-  } catch (e) {
-    return {
-      supportWebSocket: false,
-      supportEME: false,
-      hasStorage: false
+    const now = Date.now();
+    const last = lastReportedAtByCode[code] || 0;
+    if (now - last < REPORT_THROTTLE_MS) {
+      return Promise.resolve(null);
+    }
+    lastReportedAtByCode[code] = now;
+    const enriched = {
+      userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "unknown",
+      component,
+      operation,
+      context: context ? redactAndTrimContext(context) : void 0,
+      version: VERSION
     };
+    logger$2.error("SDK_CRITICAL", {
+      code,
+      component,
+      operation,
+      ...enriched.context ? { context: enriched.context } : {}
+    });
+    const err = new SDKError(code, ErrorCode.UNKNOWN, {
+      component,
+      operation,
+      ...enriched.context ? { context: enriched.context } : {}
+    });
+    return rollbarClient.reportError(err, enriched, "critical");
+  } catch {
+    return Promise.resolve(null);
   }
 }
-const mediaKeyWindow = new WindowWrapper();
-function detectDRMMethodSupport() {
-  let returnString = "";
-  returnString = checkOIPFDRMAgentObj();
-  try {
-    const hasMediaKeys = mediaKeyWindow.has("MediaKeys");
-    const hasWebKitMediaKeys = mediaKeyWindow.has("WebKitMediaKeys");
-    const hasMSMediaKeys = mediaKeyWindow.has("MSMediaKeys");
-    const eme = hasMediaKeys || hasWebKitMediaKeys || hasMSMediaKeys;
-    returnString = eme ? "EME" : returnString;
-    return { drmMethod: returnString };
-  } catch (e) {
-    return { drmMethod: "" };
-  }
-}
-function checkOIPFDRMAgentObj() {
-  try {
-    const testObject = document.createElement("object");
-    testObject.type = "application/oipfdrmagent";
-    const agent = testObject;
-    if (typeof agent.sendDRMMessage === "function") {
-      return "OIPF";
+const rollbarClient$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  reportCriticalCode,
+  rollbarClient
+}, Symbol.toStringTag, { value: "Module" }));
+const log$l = getLogger("TVPlatform");
+class TVPlatform extends BasePlatform {
+  // 7 days
+  constructor(config, bridge) {
+    super(config);
+    __publicField(this, "DEFAULT_DEVICE_INFO", {});
+    __publicField(this, "bridge");
+    __publicField(this, "isInitialized", false);
+    __publicField(this, "CACHE_KEY", "titansdk");
+    __publicField(this, "CACHE_EXPIRY", 7 * 24 * 60 * 60 * 1e3);
+    if (bridge) {
+      this.bridge = bridge;
     } else {
-      return "";
+      const bridgeConfig = {
+        gatewayUrl: this.config.gatewayUrl
+      };
+      this.bridge = new EnhancedBaseBridge(bridgeConfig);
     }
-  } catch (e) {
-    return "";
+    this.initializeBridgeSafely();
   }
-}
-function detectEMESupport() {
-  try {
-    const hasMediaKeys = mediaKeyWindow.has("MediaKeys");
-    const hasWebKitMediaKeys = mediaKeyWindow.has("WebKitMediaKeys");
-    const hasMSMediaKeys = mediaKeyWindow.has("MSMediaKeys");
-    return { supportEME: hasMediaKeys || hasWebKitMediaKeys || hasMSMediaKeys };
-  } catch (e) {
-    return { supportEME: false };
+  async initializeBridgeSafely() {
+    try {
+      const success = await this.bridge.initialize();
+      if (success) {
+        this.isInitialized = true;
+      }
+    } catch (error) {
+      log$l.warn("Bridge initialization failed:", error);
+    }
+    this.waitReadyResolver(true);
   }
-}
-const log$k = getLogger("PhilipsCapabilities");
-function checkPlayreadySupport() {
-  const config = [
-    {
-      initDataTypes: ["cenc"],
-      audioCapabilities: [
-        {
-          contentType: 'audio/mp4;codecs="mp4a.40.2"'
+  getFromLocalStorage() {
+    try {
+      if (typeof localStorage === "undefined") {
+        return null;
+      }
+      if (!localStorage.getItem) {
+        return null;
+      }
+      const cached = localStorage.getItem(this.CACHE_KEY);
+      if (!cached) {
+        return null;
+      }
+      const parsed = JSON.parse(cached);
+      if (Date.now() - parsed.timestamp > this.CACHE_EXPIRY || parsed.lastVersion !== VERSION) {
+        localStorage.removeItem(this.CACHE_KEY);
+        return null;
+      }
+      log$l.debug("Device info loaded from localStorage cache");
+      return parsed;
+    } catch (error) {
+      log$l.warn("Failed to load device info from localStorage:", error);
+      return null;
+    }
+  }
+  getFromURL() {
+    try {
+      const urlParams = new URLSearchParams(window.location.search);
+      const titansdkParam = urlParams.get("titandata");
+      if (!titansdkParam) {
+        return null;
+      }
+      let decoded = null;
+      const windowWrapper2 = new WindowWrapper();
+      try {
+        decoded = lzStringExports.decompressFromEncodedURIComponent(titansdkParam);
+        if (decoded) {
+          log$l.debug("Device info loaded from URL parameter (lz-string)");
         }
-      ],
-      videoCapabilities: [
-        {
-          contentType: 'video/mp4;codecs="avc1.42E01E"'
+      } catch (lzError) {
+        log$l.debug("lz-string decompression failed, trying base64");
+      }
+      if (!decoded) {
+        try {
+          const atobFunc = windowWrapper2.get("atob");
+          if (atobFunc) {
+            const urlDecoded = decodeURIComponent(titansdkParam);
+            decoded = atobFunc(urlDecoded);
+            log$l.debug("Device info loaded from URL parameter (base64)");
+          } else {
+            log$l.warn("atob function not available");
+            return null;
+          }
+        } catch (base64Error) {
+          log$l.warn("Both lz-string and base64 decoding failed");
+          return null;
         }
-      ]
+      }
+      if (!decoded) {
+        log$l.warn("Failed to decode URL parameter");
+        return null;
+      }
+      const parsed = JSON.parse(decoded);
+      return parsed;
+    } catch (error) {
+      log$l.warn("Failed to load device info from URL parameter:", error);
+      return null;
     }
-  ];
-  return new Promise((resolve) => {
+  }
+  saveToLocalStorage(data) {
     try {
-      navigator.requestMediaKeySystemAccess("com.microsoft.playready", config).then(() => {
-        resolve(true);
-      }).catch(() => {
-        resolve(false);
-      });
-    } catch (e) {
-      resolve(false);
+      if (typeof localStorage === "undefined") {
+        return;
+      }
+      if (!data || !data.deviceId || !data.brand || !data.model) {
+        log$l.warn("Skipping cache save - invalid or empty device info");
+        return;
+      }
+      const cacheData = {
+        data,
+        timestamp: Date.now(),
+        lastVersion: VERSION
+      };
+      localStorage.setItem(this.CACHE_KEY, JSON.stringify(cacheData));
+      log$l.debug("Device info saved to localStorage cache");
+    } catch (error) {
+      log$l.warn("Failed to save device info to localStorage:", error);
     }
-  });
-}
-function checkWidevineSupport() {
-  const config = [
-    {
-      initDataTypes: ["cenc"],
-      audioCapabilities: [
-        {
-          contentType: 'audio/mp4;codecs="mp4a.40.2"'
+  }
+  async getBaseDeviceInfo() {
+    const urlData = this.getFromURL();
+    if (urlData) {
+      this.saveToLocalStorage(urlData);
+      this.waitReadyResolver(true);
+      return {
+        deviceInfo: urlData,
+        tts: DEFAULT_TTS_SETTINGS,
+        tm: DEFAULT_TM_SETTINGS
+      };
+    }
+    if (this.config.useCache !== false) {
+      const localStorageData = this.getFromLocalStorage();
+      if (localStorageData) {
+        this.waitReadyResolver(true);
+        return {
+          deviceInfo: localStorageData.data,
+          tts: DEFAULT_TTS_SETTINGS,
+          tm: DEFAULT_TM_SETTINGS
+        };
+      }
+    } else if (this.config.debug) {
+      log$l.debug("Debug mode: skipping cache, fetching fresh data from iframe");
+    }
+    try {
+      await this.waitReady;
+      return await this.bridge.executeWithFallback(
+        async () => {
+          const deviceInfo = await this.bridge.getDeviceInfo();
+          if (!deviceInfo) {
+            throw new Error("Failed to get device info");
+          }
+          if (deviceInfo.deviceInfo) {
+            this.saveToLocalStorage(deviceInfo.deviceInfo);
+          }
+          return deviceInfo;
+        },
+        async () => {
+          log$l.warn("Bridge unavailable, returning fallback device info");
+          const fallbackData = {
+            deviceInfo: null,
+            tts: DEFAULT_TTS_SETTINGS,
+            tm: DEFAULT_TM_SETTINGS
+          };
+          void reportCriticalCode(
+            "SDK_BRIDGE_FALLBACK",
+            "SDK",
+            "bridge.executeWithFallback",
+            {
+              reason: "bridge unavailable",
+              platformId: this.getId(),
+              isInitialized: this.isInitialized
+            }
+          );
+          return fallbackData;
         }
-      ],
-      videoCapabilities: [
+      );
+    } catch (error) {
+      log$l.warn("Failed to get device info from bridge:", error);
+      void reportCriticalCode(
+        "SDK_BRIDGE_FALLBACK",
+        "SDK",
+        "bridge.executeWithFallback",
         {
-          contentType: 'video/mp4;codecs="avc1.42E01E"'
+          reason: "bridge exception",
+          platformId: this.getId(),
+          isInitialized: this.isInitialized,
+          error: error instanceof Error ? error.message : String(error)
         }
-      ]
-    }
-  ];
-  return new Promise((resolve) => {
-    try {
-      navigator.requestMediaKeySystemAccess("com.widevine.alpha", config).then(() => {
-        resolve(true);
-      }).catch(() => {
-        resolve(false);
-      });
-    } catch (e) {
-      resolve(false);
+      );
+      return {
+        deviceInfo: null,
+        tts: DEFAULT_TTS_SETTINGS,
+        tm: DEFAULT_TM_SETTINGS
+      };
     }
-  });
-}
-async function getCapabilities$1(_platform) {
+  }
+  isTV() {
+    return typeof window !== "undefined" && (navigator.userAgent.includes("TV") || navigator.userAgent.includes("SmartTV") || navigator.userAgent.includes("SMART-TV") || window.location.href.includes("file://"));
+  }
+}
+const oipfWindow = new WindowWrapper();
+const windowStorage = new WindowWrapper();
+function detectStreamingSupport() {
+  const video = document.createElement("video");
+  if (!!video.canPlayType && typeof video.canPlayType === "function") {
+    return {
+      supportAppleHLS: video.canPlayType("application/vnd.apple.mpegURL") !== "" || video.canPlayType("audio/mpegurl") !== "",
+      supportMSSmoothStreaming: video.canPlayType("application/vnd.ms-sstr+xml") !== "",
+      supportMSSInitiator: video.canPlayType("application/vnd.ms-playready.initiator+xml") !== "",
+      supportMPEG_DASH: video.canPlayType("application/dash+xml") !== "" || "unknown"
+    };
+  }
+  return {
+    supportAppleHLS: false,
+    supportMSSmoothStreaming: false,
+    supportMSSInitiator: false,
+    supportMPEG_DASH: "unknown"
+  };
+}
+function detect3DUHDSupport() {
+  try {
+    const sysinfoElement = document.createElement("object");
+    sysinfoElement.setAttribute("id", "sysinfo");
+    sysinfoElement.setAttribute("type", "systeminfoobject");
+    document.body.appendChild(sysinfoElement);
+    const sysinfo = sysinfoElement;
+    const result = {
+      support3d: Boolean(sysinfo.has3D),
+      supportUHD: sysinfo.panelinfo?.toLowerCase() === "3840x2160"
+    };
+    return { ...result, supportFHD: true };
+  } catch (error) {
+    return {
+      support3d: false,
+      supportUHD: false,
+      supportFHD: true
+    };
+  }
+}
+function detectOIPFSupport() {
+  try {
+    if (oipfWindow.get("oipfObjectFactory") !== void 0) {
+      return { supportOIPF: true };
+    }
+    const testObject = document.createElement("object");
+    testObject.type = "application/oipfdrmagent";
+    const agent = testObject;
+    if (typeof agent.sendDRMMessage === "function") {
+      return { supportOIPF: true };
+    }
+    return { supportOIPF: false };
+  } catch (e) {
+    return { supportOIPF: false };
+  }
+}
+function detectBrowserCapabilities() {
+  try {
+    const navigatorWrapper = new WindowWrapper();
+    const navigatorObj = navigatorWrapper.get("navigator");
+    const hasRequestMediaKeySystemAccess = navigatorObj !== void 0 && typeof navigatorObj.requestMediaKeySystemAccess === "function";
+    const hasMSMediaKeys = windowStorage.has("MSMediaKeys");
+    return {
+      supportWebSocket: windowStorage.has("WebSocket"),
+      supportEME: hasRequestMediaKeySystemAccess || hasMSMediaKeys,
+      hasStorage: windowStorage.has("localStorage") && windowStorage.has("sessionStorage")
+    };
+  } catch (e) {
+    return {
+      supportWebSocket: false,
+      supportEME: false,
+      hasStorage: false
+    };
+  }
+}
+const mediaKeyWindow = new WindowWrapper();
+function detectDRMMethodSupport() {
+  let returnString = "";
+  returnString = checkOIPFDRMAgentObj();
+  try {
+    const hasMediaKeys = mediaKeyWindow.has("MediaKeys");
+    const hasWebKitMediaKeys = mediaKeyWindow.has("WebKitMediaKeys");
+    const hasMSMediaKeys = mediaKeyWindow.has("MSMediaKeys");
+    const eme = hasMediaKeys || hasWebKitMediaKeys || hasMSMediaKeys;
+    returnString = eme ? "EME" : returnString;
+    return { drmMethod: returnString };
+  } catch (e) {
+    return { drmMethod: "" };
+  }
+}
+function checkOIPFDRMAgentObj() {
+  try {
+    const testObject = document.createElement("object");
+    testObject.type = "application/oipfdrmagent";
+    const agent = testObject;
+    if (typeof agent.sendDRMMessage === "function") {
+      return "OIPF";
+    } else {
+      return "";
+    }
+  } catch (e) {
+    return "";
+  }
+}
+function detectEMESupport() {
+  try {
+    const hasMediaKeys = mediaKeyWindow.has("MediaKeys");
+    const hasWebKitMediaKeys = mediaKeyWindow.has("WebKitMediaKeys");
+    const hasMSMediaKeys = mediaKeyWindow.has("MSMediaKeys");
+    return { supportEME: hasMediaKeys || hasWebKitMediaKeys || hasMSMediaKeys };
+  } catch (e) {
+    return { supportEME: false };
+  }
+}
+const log$k = getLogger("PhilipsCapabilities");
+function checkPlayreadySupport() {
+  const config = [
+    {
+      initDataTypes: ["cenc"],
+      audioCapabilities: [
+        {
+          contentType: 'audio/mp4;codecs="mp4a.40.2"'
+        }
+      ],
+      videoCapabilities: [
+        {
+          contentType: 'video/mp4;codecs="avc1.42E01E"'
+        }
+      ]
+    }
+  ];
+  return new Promise((resolve) => {
+    try {
+      navigator.requestMediaKeySystemAccess("com.microsoft.playready", config).then(() => {
+        resolve(true);
+      }).catch(() => {
+        resolve(false);
+      });
+    } catch (e) {
+      resolve(false);
+    }
+  });
+}
+function checkWidevineSupport() {
+  const config = [
+    {
+      initDataTypes: ["cenc"],
+      audioCapabilities: [
+        {
+          contentType: 'audio/mp4;codecs="mp4a.40.2"'
+        }
+      ],
+      videoCapabilities: [
+        {
+          contentType: 'video/mp4;codecs="avc1.42E01E"'
+        }
+      ]
+    }
+  ];
+  return new Promise((resolve) => {
+    try {
+      navigator.requestMediaKeySystemAccess("com.widevine.alpha", config).then(() => {
+        resolve(true);
+      }).catch(() => {
+        resolve(false);
+      });
+    } catch (e) {
+      resolve(false);
+    }
+  });
+}
+async function getCapabilities$1(_platform) {
   const playreadySupported = await checkPlayreadySupport();
   const widevineSupported = await checkWidevineSupport();
   const capabilities = {
@@ -4418,6 +4901,16 @@ class PhilipsCompat extends TVPlatform {
     legacyInfo.Product.platform = platform;
     legacyInfo.Product.language = data.deviceInfo.language;
     legacyInfo.Product.mac = data.deviceInfo.mac;
+    if (!legacyInfo.Product.mac) {
+      void reportCriticalCode(
+        "SDK_BRIDGE_NO_MAC",
+        "SDK",
+        "formatBridgeResponse",
+        {
+          deviceInfo: data.deviceInfo
+        }
+      );
+    }
     legacyInfo.Product.ifa = data.deviceInfo.ifa || "";
     legacyInfo.Product.ifaType = data.deviceInfo.ifaType || "";
     legacyInfo.Product.year = data.deviceInfo.year || "";
@@ -4970,7 +5463,7 @@ function getCapabilities(_platform) {
   };
   if (_platform === "MB191") {
     capabilities.supportHDR_DV = false;
-    capabilities.supportHDR_HDR10 = false;
+    capabilities.supportHDR_HDR10 = true;
     capabilities.supportDolbyAtmos = false;
   }
   return {
@@ -5037,32 +5530,26 @@ class VestelCompat extends TVPlatform {
   }
   async fetchDeviceInfoInternal() {
     try {
-      if (await this.waitReady) {
-        const bridgeInfo = await this.getBaseDeviceInfo();
-        const legacyInfo = {
-          Channel: this.DEFAULT_DEVICE_INFO.Channel,
-          Product: this.DEFAULT_DEVICE_INFO.Product
-        };
-        const infoWithProduct = this.formatBridgeResponse(
-          bridgeInfo,
-          legacyInfo
-        );
-        const platform = infoWithProduct.Product.platform;
-        const capabilities = getCapabilities(platform);
-        return {
-          ...infoWithProduct,
-          Capability: capabilities
-        };
-      }
+      const bridgeInfo = await this.getBaseDeviceInfo();
+      const legacyInfo = {
+        Channel: this.DEFAULT_DEVICE_INFO.Channel,
+        Product: this.DEFAULT_DEVICE_INFO.Product
+      };
+      const infoWithProduct = this.formatBridgeResponse(bridgeInfo, legacyInfo);
+      const platform = infoWithProduct.Product.platform;
+      const capabilities = getCapabilities(platform);
+      return {
+        ...infoWithProduct,
+        Capability: capabilities
+      };
+    } catch (error) {
+      log$c.error("Error getting device info:", error);
       const fallbackCapabilities = getCapabilities();
       return {
         Channel: this.DEFAULT_DEVICE_INFO.Channel,
         Product: this.DEFAULT_DEVICE_INFO.Product,
         Capability: fallbackCapabilities
       };
-    } catch (error) {
-      log$c.error("Error getting device info:", error);
-      throw error;
     }
   }
   formatBridgeResponse(data, legacyInfo) {
@@ -5420,7 +5907,7 @@ class BrowserAccessibilityService {
     log$8.info("TM settings updated:", this.tmSettings);
   }
 }
-const logger$2 = getLogger("BrowserPlatform");
+const logger$1 = getLogger("BrowserPlatform");
 class BrowserCompat extends BasePlatform {
   constructor(config) {
     super(config);
@@ -5436,7 +5923,7 @@ class BrowserCompat extends BasePlatform {
     return true;
   }
   async getDeviceInfo() {
-    logger$2.debug("Getting default device info for browser");
+    logger$1.debug("Getting default device info for browser");
     return this.getDefaultDeviceInfo();
   }
   getDefaultDeviceInfo() {
@@ -5740,7 +6227,7 @@ class PhilipsOldAccessibilityService {
     return false;
   }
 }
-const logger$1 = getLogger("PhilipsOldPlatform");
+const logger = getLogger("PhilipsOldPlatform");
 class PhilipsOldCompat extends BasePlatform {
   constructor(config) {
     super(config);
@@ -5778,484 +6265,206 @@ class PhilipsOldCompat extends BasePlatform {
     }
     const userAgent = navigator.userAgent.toLowerCase();
     const philipsPatterns = ["philips", "saphi", "nettv", "tpvision"];
-    return philipsPatterns.some((pattern) => userAgent.includes(pattern));
-  }
-  async getDeviceInfo() {
-    if (this.deviceInfo) {
-      return this.deviceInfo;
-    }
-    if (this.deviceInfoPromise) {
-      return await this.deviceInfoPromise;
-    }
-    this.deviceInfoPromise = this.fetchDeviceInfoInternal();
-    try {
-      const result = await this.deviceInfoPromise;
-      this.deviceInfo = result;
-      return result;
-    } catch (error) {
-      this.deviceInfoPromise = null;
-      throw error;
-    }
-  }
-  async fetchDeviceInfoInternal() {
-    try {
-      if (await this.waitReady) {
-        const bridgeInfo = await this.fetchDeviceInfo();
-        const legacyInfo = {
-          Channel: this.DEFAULT_DEVICE_INFO.Channel,
-          Product: this.DEFAULT_DEVICE_INFO.Product
-        };
-        if (!bridgeInfo) {
-          const capabilities3 = await getCapabilities$1();
-          return {
-            ...legacyInfo,
-            Capability: capabilities3
-          };
-        }
-        const formatted = this.formatBridgeResponse(
-          {
-            deviceInfo: bridgeInfo,
-            tts: DEFAULT_TTS_SETTINGS,
-            tm: DEFAULT_TM_SETTINGS
-          },
-          legacyInfo
-        );
-        const platform = formatted.Product.platform;
-        const capabilities2 = await getCapabilities$1(platform);
-        return {
-          ...formatted,
-          Capability: capabilities2
-        };
-      }
-      const capabilities = await getCapabilities$1();
-      return {
-        Channel: this.DEFAULT_DEVICE_INFO.Channel,
-        Product: this.DEFAULT_DEVICE_INFO.Product,
-        Capability: capabilities
-      };
-    } catch (error) {
-      logger$1.warn("Error getting device info:", error);
-      throw error;
-    }
-  }
-  async fetchDeviceInfo() {
-    try {
-      const domain = "app.titanos.tv";
-      const backendInfo = await Promise.race([
-        getDeviceInfoFromBackend(
-          null,
-          domain,
-          "zeasn"
-        ),
-        new Promise((resolve) => {
-          setTimeout(() => {
-            logger$1.warn("Zeasn backend device info request timed out");
-            resolve(null);
-          }, this.timeout);
-        })
-      ]);
-      if (!backendInfo || !backendInfo.datas?.cookies) {
-        return null;
-      }
-      const profileId = backendInfo.datas.cookies.profileid;
-      const deviceInfo = {
-        profileId,
-        deviceId: decodeURIComponent(backendInfo.datas.cookies.deviceid || ""),
-        model: backendInfo.datas.cookies.deviceYear || "",
-        year: backendInfo.datas.cookies.deviceYear || "",
-        firmwareVersion: backendInfo.datas.cookies.ufversion || "",
-        country: backendInfo.datas.cookies.country || "",
-        language: getBrowserLanguage("en"),
-        brand: PlatformName.PHILIPS,
-        platformName: PlatformName.PHILIPS,
-        mac: decodeURIComponent(backendInfo.datas.cookies.mac || ""),
-        ifa: "",
-        ifaType: ""
-      };
-      return deviceInfo;
-    } catch (error) {
-      logger$1.warn("Error fetching device info from backend", error);
-      return null;
-    }
-  }
-  formatBridgeResponse(data, legacyInfo) {
-    let platform = "TitanOS";
-    let firmwareComponentID = "unknown";
-    if (!data.deviceInfo) {
-      return legacyInfo;
-    }
-    if (data.deviceInfo.profileId) {
-      platform = data.deviceInfo.platformName;
-      if (data.deviceInfo.profileId) {
-        var profileInfo = data.deviceInfo.profileId.split("_");
-        platform = (profileInfo[1] || platform).replace(/\d+$/, "");
-        firmwareComponentID = profileInfo[1] ? decodeURIComponent(profileInfo[1]) : "unknown";
-      }
-    }
-    legacyInfo.Product.firmwareVersion = data.deviceInfo.firmwareVersion;
-    legacyInfo.Product.country = data.deviceInfo.country;
-    legacyInfo.Product.deviceID = data.deviceInfo.deviceId;
-    legacyInfo.Product.platform = platform;
-    legacyInfo.Product.language = data.deviceInfo.language;
-    legacyInfo.Product.mac = data.deviceInfo.mac;
-    legacyInfo.Product.ifa = data.deviceInfo.ifa || "";
-    legacyInfo.Product.ifaType = data.deviceInfo.ifaType || "";
-    legacyInfo.Product.year = data.deviceInfo.year || "";
-    legacyInfo.Product.firmwareComponentID = firmwareComponentID;
-    return legacyInfo;
-  }
-  getPriority() {
-    return 100;
-  }
-  getId() {
-    return "philips";
-  }
-}
-class PhilipsOldDeviceInfoService {
-  constructor(config) {
-    __publicField(this, "platform");
-    __publicField(this, "info");
-    this.platform = new PhilipsOldCompat(config);
-    this.info = null;
-  }
-  async getDeviceInfo() {
-    const legacyInfo = await this.platform.getDeviceInfo();
-    this.info = legacyInfo;
-    return this.info;
-  }
-  async getCapabilities() {
-    if (!this.info) {
-      this.info = await this.getDeviceInfo();
-    }
-    return this.info.Capability;
-  }
-}
-class PhilipsOldAppControlService {
-  async launch(_appId, _deepLink) {
-    return false;
-  }
-}
-class PhilipsOldSDK {
-  constructor(options) {
-    __publicField(this, "accessibilityService");
-    __publicField(this, "deviceInfoService");
-    __publicField(this, "appControlService");
-    __publicField(this, "deviceInfo", {
-      getDeviceInfo: () => this.deviceInfoService.getDeviceInfo(),
-      getCapabilities: () => this.deviceInfoService.getCapabilities()
-    });
-    __publicField(this, "accessibility", {
-      enableReader: (config) => this.accessibilityService.enableReader(config),
-      disableReader: () => this.accessibilityService.disableReader(),
-      isTTSSupported: () => this.accessibilityService.isTTSSupported(),
-      isTTSEnabled: () => this.accessibilityService.isTTSEnabled(),
-      isTMEnabled: () => this.accessibilityService.isTMEnabled(),
-      isTextMagnificationSupported: () => this.accessibilityService.isTextMagnificationSupported(),
-      getTTSSettings: async () => convertToPublicSettings(await this.accessibilityService.getTTSSettings()),
-      getTMSettings: async () => convertToPublicSettings(await this.accessibilityService.getTMSettings()),
-      startSpeaking: (text) => this.accessibilityService.startSpeaking(text),
-      stopSpeaking: () => this.accessibilityService.stopSpeaking(),
-      onTTSSettingsChange: (_callback) => {
-        return () => {
-        };
-      },
-      onTMSettingsChange: (_callback) => {
-        return () => {
-        };
-      }
-    });
-    __publicField(this, "apps", {
-      launch: (appId, deepLink) => this.appControlService.launch(appId, deepLink)
-    });
-    this.accessibilityService = new PhilipsOldAccessibilityService();
-    this.deviceInfoService = new PhilipsOldDeviceInfoService(options);
-    this.appControlService = new PhilipsOldAppControlService();
-  }
-  get logging() {
-    return new LoggingService();
-  }
-  async init() {
-    return true;
-  }
-}
-const logger = getLogger("RollbarClient");
-const IGNORED_ERROR_PATTERNS = [
-  "chrome://userjs/",
-  "chrome-extension://",
-  "moz-extension://",
-  "getJWTString",
-  "getjwtstring",
-  "user.js",
-  "userscript",
-  "tampermonkey",
-  "greasemonkey",
-  "can't find variable getjwtstring",
-  "referenceerror: can't find variable: getjwtstring",
-  "unexpected end of json input",
-  "jsonparse"
-];
-class RollbarClient {
-  constructor() {
-    __publicField(this, "rollbar", null);
-    __publicField(this, "config", null);
-    __publicField(this, "windowWrapper", new WindowWrapper());
-  }
-  initialize(config) {
-    if (!config.enabled || !config.accessToken) {
-      logger.warn("Rollbar not initialized - disabled or missing access token");
-      return;
-    }
-    try {
-      this.config = config;
-      this.rollbar = new Rollbar({
-        accessToken: config.accessToken,
-        environment: config.environment || getEnvironment(),
-        captureUncaught: true,
-        captureUnhandledRejections: true,
-        verbose: false,
-        reportLevel: "error",
-        captureIp: false,
-        captureUsername: false,
-        captureEmail: false,
-        maxItems: 100,
-        itemsPerMinute: 60,
-        captureLambdaTimeouts: false,
-        endpoint: `${getLogsDomain()}/logs/`,
-        autoInstrument: {
-          network: false,
-          log: false,
-          dom: false,
-          navigation: false,
-          connectivity: false
-        },
-        payload: {
-          client: {
-            javascript: {
-              code_version: "unknown",
-              source_map_enabled: true
-            }
-          }
-        },
-        transform: (payload) => {
-          if (payload.context) {
-            payload.context = `hephaestus-${payload.context}`;
-          }
-        },
-        checkIgnore: (_isUncaught, args, _payload) => {
-          const error = args[0];
-          const errorMessage = typeof error === "string" ? error : error?.message;
-          const errorStack = typeof error === "object" && error ? error.stack : "";
-          const errorString = String(error).toLowerCase();
-          const ignoredPatterns = IGNORED_ERROR_PATTERNS;
-          return ignoredPatterns.some(
-            (pattern) => errorMessage?.toLowerCase().includes(pattern.toLowerCase()) || errorStack?.toLowerCase().includes(pattern.toLowerCase()) || errorString.includes(pattern.toLowerCase())
-          );
-        }
-      });
-      this.setupGlobalErrorHandlers();
-      logger.info("Rollbar initialized successfully", {
-        environment: config.environment
-      });
-    } catch (error) {
-      logger.error("Failed to initialize Rollbar", { error, config });
-    }
-  }
-  shouldIgnoreError(error) {
-    if (!error) return true;
-    const errorMessage = typeof error === "string" ? error : error.message || "";
-    const errorStack = typeof error === "object" ? error.stack || "" : "";
-    const errorString = String(error).toLowerCase();
-    const ignoredPatterns = IGNORED_ERROR_PATTERNS;
-    return ignoredPatterns.some(
-      (pattern) => errorMessage?.toLowerCase().includes(pattern.toLowerCase()) || errorStack?.toLowerCase().includes(pattern.toLowerCase()) || errorString.includes(pattern.toLowerCase())
-    );
-  }
-  async reportError(error, additionalData, severity = "error") {
-    if (!this.rollbar || !this.config?.enabled || !error) {
-      return Promise.resolve(null);
-    }
-    if (this.shouldIgnoreError(error)) {
-      return Promise.resolve(null);
-    }
-    return new Promise((resolve) => {
-      this.getDeviceContext().then((deviceContext) => {
-        try {
-          const allLogs = LogManager.getHistory().filter(
-            (log2) => !log2.module.includes("RollbarClient") && !log2.message.includes("Rollbar") && log2.level !== "debug"
-          ).slice(-20);
-          const logsString = allLogs.map(
-            (log2) => `[${log2.timestamp}] ${log2.module}: ${log2.message}${log2.args && log2.args.length > 0 ? "\n  Args: " + JSON.stringify(log2.args) : ""}`
-          ).join("\n");
-          const context = {
-            logs: logsString,
-            component: additionalData?.component || "SDK",
-            operation: additionalData?.operation,
-            requestId: additionalData?.requestId,
-            timestamp: Date.now(),
-            url: typeof window !== "undefined" ? window.location?.href : void 0,
-            userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "unknown",
-            sessionId: this.generateSessionId(),
-            errorStack: typeof error === "object" ? error.stack : void 0,
-            version: typeof window !== "undefined" ? this.windowWrapper.get("TitanSDK")?.VERSION || "unknown" : "unknown",
-            ...deviceContext,
-            ...additionalData
-          };
-          const rollbarMethod = severity === "critical" ? "critical" : "error";
-          const errorType = severity === "critical" ? "critical_error_with_logs" : "error_with_logs";
-          this.rollbar?.[rollbarMethod](
-            error,
-            {
-              custom: {
-                type: errorType,
-                context,
-                logCount: allLogs.length
-              }
-            },
-            (err, data) => {
-              if (err) {
-                if (!this.shouldIgnoreError(err)) {
-                  logger.error(
-                    `Failed to send ${severity} error to Rollbar`,
-                    {
-                      error: err,
-                      originalError: error
-                    }
-                  );
-                }
-                resolve(null);
-              } else {
-                const rollbarId = data ? data.uuid || data.result?.uuid || null : null;
-                logger.info(
-                  `${severity === "critical" ? "Critical error" : "Error"} sent to Rollbar`,
-                  {
-                    message: typeof error === "string" ? error : error?.message || "Unknown error",
-                    component: context.component,
-                    rollbarId,
-                    logCount: allLogs.length
-                  }
-                );
-                resolve(rollbarId);
-              }
-            }
-          );
-        } catch (rollbarError) {
-          logger.error(`Failed to send ${severity} error to Rollbar`, {
-            error: rollbarError,
-            originalError: error
-          });
-          resolve(null);
-        }
-      }).catch((deviceError) => {
-        logger.error(`Failed to get device context for ${severity} error`, {
-          error: deviceError
-        });
-        resolve(null);
-      });
-    });
+    return philipsPatterns.some((pattern) => userAgent.includes(pattern));
   }
-  collectSDKUsage(functionName, result, success, component) {
-    if (!this.rollbar || !this.config?.enabled) return;
+  async getDeviceInfo() {
+    if (this.deviceInfo) {
+      return this.deviceInfo;
+    }
+    if (this.deviceInfoPromise) {
+      return await this.deviceInfoPromise;
+    }
+    this.deviceInfoPromise = this.fetchDeviceInfoInternal();
     try {
-      const logLevel = success ? "info" : "warning";
-      this.rollbar[logLevel](`SDK function execution: ${functionName}`, {
-        custom: {
-          type: "sdk_function_execution",
-          functionName,
-          success,
-          component,
-          result: success ? result : void 0,
-          error: !success ? result : void 0,
-          timestamp: Date.now(),
-          url: typeof window !== "undefined" ? window.location?.href : void 0
-        }
-      });
-      logger.info("SDK function execution logged", {
-        functionName,
-        success,
-        component
-      });
+      const result = await this.deviceInfoPromise;
+      this.deviceInfo = result;
+      return result;
     } catch (error) {
-      logger.error("Failed to log SDK function execution", {
-        error,
-        functionName,
-        component
-      });
+      this.deviceInfoPromise = null;
+      throw error;
     }
   }
-  generateSessionId() {
-    return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-  async getDeviceContext() {
+  async fetchDeviceInfoInternal() {
     try {
-      if (window?.TitanSDK) {
-        try {
-          const deviceInfo = await window?.TitanSDK?.deviceInfo?.getDeviceInfo?.();
+      if (await this.waitReady) {
+        const bridgeInfo = await this.fetchDeviceInfo();
+        const legacyInfo = {
+          Channel: this.DEFAULT_DEVICE_INFO.Channel,
+          Product: this.DEFAULT_DEVICE_INFO.Product
+        };
+        if (!bridgeInfo) {
+          const capabilities3 = await getCapabilities$1();
           return {
-            deviceInfo: deviceInfo ? JSON.stringify(deviceInfo) : "unavailable"
+            ...legacyInfo,
+            Capability: capabilities3
           };
-        } catch (sdkError) {
         }
+        const formatted = this.formatBridgeResponse(
+          {
+            deviceInfo: bridgeInfo,
+            tts: DEFAULT_TTS_SETTINGS,
+            tm: DEFAULT_TM_SETTINGS
+          },
+          legacyInfo
+        );
+        const platform = formatted.Product.platform;
+        const capabilities2 = await getCapabilities$1(platform);
+        return {
+          ...formatted,
+          Capability: capabilities2
+        };
       }
+      const capabilities = await getCapabilities$1();
       return {
-        deviceInfo: `OS: ${navigator?.platform || "unknown"}, Browser: ${this.detectBrowserEngine()}, Storage: ${"localStorage" in (window || {})}`
+        Channel: this.DEFAULT_DEVICE_INFO.Channel,
+        Product: this.DEFAULT_DEVICE_INFO.Product,
+        Capability: capabilities
       };
     } catch (error) {
-      return {};
+      logger.warn("Error getting device info:", error);
+      throw error;
     }
   }
-  detectBrowserEngine() {
-    if (typeof navigator === "undefined") return "unknown";
-    const userAgent = navigator.userAgent;
-    if (userAgent.includes("Chrome")) return "Blink";
-    if (userAgent.includes("Firefox")) return "Gecko";
-    if (userAgent.includes("Safari") && !userAgent.includes("Chrome"))
-      return "WebKit";
-    if (userAgent.includes("Edge")) return "EdgeHTML";
-    return "unknown";
+  async fetchDeviceInfo() {
+    try {
+      const domain = "app.titanos.tv";
+      const backendInfo = await Promise.race([
+        getDeviceInfoFromBackend(
+          null,
+          domain,
+          "zeasn"
+        ),
+        new Promise((resolve) => {
+          setTimeout(() => {
+            logger.warn("Zeasn backend device info request timed out");
+            resolve(null);
+          }, this.timeout);
+        })
+      ]);
+      if (!backendInfo || !backendInfo.datas?.cookies) {
+        return null;
+      }
+      const profileId = backendInfo.datas.cookies.profileid;
+      const deviceInfo = {
+        profileId,
+        deviceId: decodeURIComponent(backendInfo.datas.cookies.deviceid || ""),
+        model: backendInfo.datas.cookies.deviceYear || "",
+        year: backendInfo.datas.cookies.deviceYear || "",
+        firmwareVersion: backendInfo.datas.cookies.ufversion || "",
+        country: backendInfo.datas.cookies.country || "",
+        language: getBrowserLanguage("en"),
+        brand: PlatformName.PHILIPS,
+        platformName: PlatformName.PHILIPS,
+        mac: decodeURIComponent(backendInfo.datas.cookies.mac || ""),
+        ifa: "",
+        ifaType: ""
+      };
+      return deviceInfo;
+    } catch (error) {
+      logger.warn("Error fetching device info from backend", error);
+      return null;
+    }
   }
-  setupGlobalErrorHandlers() {
-    if (typeof window === "undefined") return;
-    const originalConsoleError = console.error;
-    console.error = (...args) => {
-      originalConsoleError.apply(console, args);
-      const errorArg = args.find(
-        (arg) => arg instanceof Error || typeof arg === "string" && arg.includes("Error")
-      );
-      if (errorArg && !this.shouldIgnoreError(errorArg)) {
-        this.reportError(errorArg, {
-          component: "SDK",
-          operation: "console.error"
-        });
+  formatBridgeResponse(data, legacyInfo) {
+    let platform = "TitanOS";
+    let firmwareComponentID = "unknown";
+    if (!data.deviceInfo) {
+      return legacyInfo;
+    }
+    if (data.deviceInfo.profileId) {
+      platform = data.deviceInfo.platformName;
+      if (data.deviceInfo.profileId) {
+        var profileInfo = data.deviceInfo.profileId.split("_");
+        platform = (profileInfo[1] || platform).replace(/\d+$/, "");
+        firmwareComponentID = profileInfo[1] ? decodeURIComponent(profileInfo[1]) : "unknown";
       }
-    };
-    if (typeof window !== "undefined") {
-      window.addEventListener("error", (event) => {
-        if (!this.shouldIgnoreError(event.error)) {
-          this.reportError(event.error || event.message, {
-            component: "SDK",
-            operation: "window.onerror"
-          });
-        }
-      });
-      window.addEventListener("unhandledrejection", (event) => {
-        if (!this.shouldIgnoreError(event.reason)) {
-          this.reportError(event.reason, {
-            component: "SDK",
-            operation: "unhandledrejection"
-          });
-        }
-      });
     }
+    legacyInfo.Product.firmwareVersion = data.deviceInfo.firmwareVersion;
+    legacyInfo.Product.country = data.deviceInfo.country;
+    legacyInfo.Product.deviceID = data.deviceInfo.deviceId;
+    legacyInfo.Product.platform = platform;
+    legacyInfo.Product.language = data.deviceInfo.language;
+    legacyInfo.Product.mac = data.deviceInfo.mac;
+    legacyInfo.Product.ifa = data.deviceInfo.ifa || "";
+    legacyInfo.Product.ifaType = data.deviceInfo.ifaType || "";
+    legacyInfo.Product.year = data.deviceInfo.year || "";
+    legacyInfo.Product.firmwareComponentID = firmwareComponentID;
+    return legacyInfo;
   }
-  isInitialized() {
-    return this.rollbar !== null && this.config?.enabled === true;
+  getPriority() {
+    return 100;
+  }
+  getId() {
+    return "philips";
+  }
+}
+class PhilipsOldDeviceInfoService {
+  constructor(config) {
+    __publicField(this, "platform");
+    __publicField(this, "info");
+    this.platform = new PhilipsOldCompat(config);
+    this.info = null;
+  }
+  async getDeviceInfo() {
+    const legacyInfo = await this.platform.getDeviceInfo();
+    this.info = legacyInfo;
+    return this.info;
+  }
+  async getCapabilities() {
+    if (!this.info) {
+      this.info = await this.getDeviceInfo();
+    }
+    return this.info.Capability;
+  }
+}
+class PhilipsOldAppControlService {
+  async launch(_appId, _deepLink) {
+    return false;
+  }
+}
+class PhilipsOldSDK {
+  constructor(options) {
+    __publicField(this, "accessibilityService");
+    __publicField(this, "deviceInfoService");
+    __publicField(this, "appControlService");
+    __publicField(this, "deviceInfo", {
+      getDeviceInfo: () => this.deviceInfoService.getDeviceInfo(),
+      getCapabilities: () => this.deviceInfoService.getCapabilities()
+    });
+    __publicField(this, "accessibility", {
+      enableReader: (config) => this.accessibilityService.enableReader(config),
+      disableReader: () => this.accessibilityService.disableReader(),
+      isTTSSupported: () => this.accessibilityService.isTTSSupported(),
+      isTTSEnabled: () => this.accessibilityService.isTTSEnabled(),
+      isTMEnabled: () => this.accessibilityService.isTMEnabled(),
+      isTextMagnificationSupported: () => this.accessibilityService.isTextMagnificationSupported(),
+      getTTSSettings: async () => convertToPublicSettings(await this.accessibilityService.getTTSSettings()),
+      getTMSettings: async () => convertToPublicSettings(await this.accessibilityService.getTMSettings()),
+      startSpeaking: (text) => this.accessibilityService.startSpeaking(text),
+      stopSpeaking: () => this.accessibilityService.stopSpeaking(),
+      onTTSSettingsChange: (_callback) => {
+        return () => {
+        };
+      },
+      onTMSettingsChange: (_callback) => {
+        return () => {
+        };
+      }
+    });
+    __publicField(this, "apps", {
+      launch: (appId, deepLink) => this.appControlService.launch(appId, deepLink)
+    });
+    this.accessibilityService = new PhilipsOldAccessibilityService();
+    this.deviceInfoService = new PhilipsOldDeviceInfoService(options);
+    this.appControlService = new PhilipsOldAppControlService();
+  }
+  get logging() {
+    return new LoggingService();
+  }
+  async init() {
+    return true;
   }
 }
-const rollbarClient = new RollbarClient();
-const rollbarClient$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  rollbarClient
-}, Symbol.toStringTag, { value: "Module" }));
 const log$3 = getLogger("SmartTvA_API");
 const initializeSmartTvAPI = async (sdk) => {
   log$3.info("Initializing SmartTvA_API with TitanSDK");
@@ -6639,10 +6848,7 @@ let sdkInstance = null;
 let sdkResult = null;
 let initPromise = null;
 let cachedDeviceInfo = null;
-rollbarClient.initialize({
-  accessToken: "",
-  enabled: false
-});
+let rollbarInitialized = false;
 const ensureInitialized = async () => {
   if (!sdkInstance) {
     throw new SDKError(
@@ -6672,6 +6878,15 @@ const getTitanSDK = (options) => {
     ...options
   };
   globalLogManager.setDebugMode(finalOptions.debug ?? false);
+  if (!rollbarInitialized) {
+    const rollbarToken = "";
+    const rollbarEnabled = false;
+    rollbarClient.initialize({
+      accessToken: rollbarToken,
+      enabled: rollbarEnabled
+    });
+    rollbarInitialized = true;
+  }
   const platformResult = platformDetector.detectPlatform(finalOptions);
   const platformType = platformResult.platform;
   log.info("Platform detected:", platformType);