@trillboards/connect 1.0.0

package/dist/index.js

@@ -0,0 +1,2146 @@
+'use strict';
+
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// src/device.js
+var require_device = __commonJS({
+  "src/device.js"(exports$1, module) {
+    var API_BASE = "https://api.trillboards.com/v1/partner";
+    var DeviceStatus = {
+      UNREGISTERED: "unregistered",
+      REGISTERING: "registering",
+      REGISTERED: "registered",
+      ONLINE: "online",
+      OFFLINE: "offline",
+      ERROR: "error"
+    };
+    function generateFingerprint(deviceId) {
+      if (!deviceId || typeof deviceId !== "string") {
+        throw new Error("deviceId must be a non-empty string");
+      }
+      let hash = 2166136261;
+      for (let i = 0; i < deviceId.length; i++) {
+        hash ^= deviceId.charCodeAt(i);
+        hash = Math.imul(hash, 16777619);
+      }
+      const hashHex = (hash >>> 0).toString(16).padStart(8, "0");
+      let extHash = 16777619;
+      for (let i = 0; i < deviceId.length; i++) {
+        extHash ^= deviceId.charCodeAt(i) * (i + 1);
+        extHash = Math.imul(extHash, 2166136261);
+      }
+      const extHex = (extHash >>> 0).toString(16).padStart(8, "0");
+      return `SDK_${hashHex}${extHex}`;
+    }
+    function collectDeviceMetadata() {
+      const metadata = {
+        sdk_version: "1.0.0",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (typeof navigator !== "undefined") {
+        metadata.user_agent = navigator.userAgent;
+        metadata.platform = navigator.platform;
+        metadata.language = navigator.language;
+        metadata.online = navigator.onLine;
+        metadata.hardware_concurrency = navigator.hardwareConcurrency;
+      }
+      if (typeof screen !== "undefined") {
+        metadata.screen_width = screen.width;
+        metadata.screen_height = screen.height;
+        metadata.pixel_ratio = typeof devicePixelRatio !== "undefined" ? devicePixelRatio : 1;
+        metadata.color_depth = screen.colorDepth;
+      }
+      return metadata;
+    }
+    async function registerDevice(apiKey, deviceId, metadata = {}) {
+      if (!apiKey) {
+        throw new Error("apiKey is required for device registration");
+      }
+      if (!deviceId) {
+        throw new Error("deviceId is required for device registration");
+      }
+      const browserMetadata = collectDeviceMetadata();
+      const displayInfo = {};
+      if (browserMetadata.screen_width) {
+        displayInfo.width = browserMetadata.screen_width;
+        displayInfo.height = browserMetadata.screen_height;
+      }
+      const body = {
+        device_id: deviceId,
+        device_type: metadata.device_type || "digital_signage",
+        name: metadata.name || `SDK Device: ${deviceId}`,
+        display: {
+          ...displayInfo,
+          ...metadata.display
+        },
+        location: metadata.location || {},
+        custom_metadata: {
+          ...browserMetadata,
+          ...metadata.custom
+        }
+      };
+      const response = await fetch(`${API_BASE}/device`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${apiKey}`,
+          "X-SDK-Version": "1.0.0"
+        },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const err = new Error(errorData.message || `Device registration failed: ${response.status}`);
+        err.statusCode = response.status;
+        err.response = errorData;
+        throw err;
+      }
+      return response.json();
+    }
+    function startHeartbeat(fingerprint, intervalMs = 6e4, options = {}) {
+      if (!fingerprint) {
+        throw new Error("fingerprint is required for heartbeat");
+      }
+      const maxRetries = options.maxRetries || 10;
+      const retryBackoff = options.retryBackoff || 1.5;
+      const onSuccess = options.onSuccess || (() => {
+      });
+      const onError = options.onError || (() => {
+      });
+      let timerId = null;
+      let consecutiveFailures = 0;
+      let totalBeats = 0;
+      let lastBeatAt = null;
+      let running = false;
+      let currentInterval = intervalMs;
+      async function sendBeat() {
+        try {
+          const response = await fetch(`${API_BASE}/device/${encodeURIComponent(fingerprint)}/heartbeat`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "X-SDK-Version": "1.0.0"
+            },
+            body: JSON.stringify({
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              total_beats: totalBeats
+            })
+          });
+          if (!response.ok) {
+            throw new Error(`Heartbeat failed: HTTP ${response.status}`);
+          }
+          const data = await response.json();
+          consecutiveFailures = 0;
+          currentInterval = intervalMs;
+          totalBeats++;
+          lastBeatAt = /* @__PURE__ */ new Date();
+          onSuccess({
+            beat: totalBeats,
+            status: data.status || "online",
+            last_seen_at: data.last_seen_at,
+            timestamp: lastBeatAt.toISOString()
+          });
+          return data;
+        } catch (err) {
+          consecutiveFailures++;
+          onError({
+            error: err.message,
+            consecutiveFailures,
+            willRetry: consecutiveFailures < maxRetries
+          });
+          if (consecutiveFailures >= maxRetries) {
+            console.error(`[Trillboards SDK] Heartbeat stopped after ${maxRetries} consecutive failures`);
+            stop();
+            return null;
+          }
+          currentInterval = Math.min(
+            intervalMs * Math.pow(retryBackoff, consecutiveFailures),
+            intervalMs * 5
+            // Cap at 5x the original interval
+          );
+          return null;
+        }
+      }
+      function scheduleNext() {
+        if (!running) return;
+        timerId = setTimeout(async () => {
+          await sendBeat();
+          scheduleNext();
+        }, currentInterval);
+      }
+      function start() {
+        if (running) return;
+        running = true;
+        consecutiveFailures = 0;
+        currentInterval = intervalMs;
+        sendBeat().then(() => {
+          scheduleNext();
+        });
+      }
+      function stop() {
+        running = false;
+        if (timerId) {
+          clearTimeout(timerId);
+          timerId = null;
+        }
+      }
+      function getStatus() {
+        return {
+          running,
+          totalBeats,
+          lastBeatAt: lastBeatAt ? lastBeatAt.toISOString() : null,
+          consecutiveFailures,
+          currentIntervalMs: currentInterval
+        };
+      }
+      return {
+        start,
+        stop,
+        getStatus,
+        sendBeat
+      };
+    }
+    var DeviceTracker = class {
+      constructor(deviceId) {
+        this.deviceId = deviceId;
+        this.status = DeviceStatus.UNREGISTERED;
+        this.fingerprint = null;
+        this.screenId = null;
+        this.embedUrl = null;
+        this.registrationData = null;
+        this.heartbeatController = null;
+        this.listeners = {};
+        this.lastError = null;
+      }
+      /**
+       * Listen for status change events
+       * @param {string} event - Event name: 'status_change', 'registered', 'error', 'heartbeat'
+       * @param {Function} callback - Event handler
+       */
+      on(event, callback) {
+        if (!this.listeners[event]) {
+          this.listeners[event] = [];
+        }
+        this.listeners[event].push(callback);
+      }
+      /**
+       * Remove an event listener
+       * @param {string} event - Event name
+       * @param {Function} callback - Handler to remove
+       */
+      off(event, callback) {
+        if (this.listeners[event]) {
+          this.listeners[event] = this.listeners[event].filter((cb) => cb !== callback);
+        }
+      }
+      /**
+       * Emit an event to all registered listeners
+       * @param {string} event - Event name
+       * @param {Object} data - Event data
+       */
+      emit(event, data) {
+        if (this.listeners[event]) {
+          this.listeners[event].forEach((cb) => {
+            try {
+              cb(data);
+            } catch (err) {
+              console.error(`[Trillboards SDK] Event listener error for '${event}':`, err);
+            }
+          });
+        }
+      }
+      /**
+       * Update device status and emit change event
+       * @param {string} newStatus - New status from DeviceStatus enum
+       */
+      setStatus(newStatus) {
+        const oldStatus = this.status;
+        this.status = newStatus;
+        if (oldStatus !== newStatus) {
+          this.emit("status_change", {
+            from: oldStatus,
+            to: newStatus,
+            deviceId: this.deviceId,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+      }
+      /**
+       * Register the device and start heartbeat
+       * @param {string} apiKey - Partner API key
+       * @param {Object} metadata - Device metadata
+       * @param {Object} heartbeatOptions - Heartbeat configuration
+       * @returns {Promise<Object>} Registration data
+       */
+      async register(apiKey, metadata = {}, heartbeatOptions = {}) {
+        this.setStatus(DeviceStatus.REGISTERING);
+        try {
+          const result = await registerDevice(apiKey, this.deviceId, metadata);
+          this.fingerprint = result.fingerprint;
+          this.screenId = result.screen_id;
+          this.embedUrl = result.embed_url;
+          this.registrationData = result;
+          this.lastError = null;
+          this.setStatus(DeviceStatus.REGISTERED);
+          this.emit("registered", result);
+          const interval = heartbeatOptions.interval || 6e4;
+          this.heartbeatController = startHeartbeat(this.fingerprint, interval, {
+            onSuccess: (data) => {
+              this.setStatus(DeviceStatus.ONLINE);
+              this.emit("heartbeat", data);
+            },
+            onError: (data) => {
+              if (!data.willRetry) {
+                this.setStatus(DeviceStatus.OFFLINE);
+              }
+              this.emit("heartbeat_error", data);
+            },
+            maxRetries: heartbeatOptions.maxRetries || 10,
+            retryBackoff: heartbeatOptions.retryBackoff || 1.5
+          });
+          this.heartbeatController.start();
+          return result;
+        } catch (err) {
+          this.lastError = err;
+          this.setStatus(DeviceStatus.ERROR);
+          this.emit("error", {
+            phase: "registration",
+            error: err.message,
+            statusCode: err.statusCode
+          });
+          throw err;
+        }
+      }
+      /**
+       * Stop heartbeat and clean up
+       */
+      destroy() {
+        if (this.heartbeatController) {
+          this.heartbeatController.stop();
+          this.heartbeatController = null;
+        }
+        this.setStatus(DeviceStatus.OFFLINE);
+        this.listeners = {};
+      }
+      /**
+       * Get the complete device state
+       * @returns {Object} Current device state
+       */
+      getState() {
+        return {
+          deviceId: this.deviceId,
+          status: this.status,
+          fingerprint: this.fingerprint,
+          screenId: this.screenId,
+          embedUrl: this.embedUrl,
+          heartbeat: this.heartbeatController ? this.heartbeatController.getStatus() : null,
+          lastError: this.lastError ? this.lastError.message : null
+        };
+      }
+    };
+    module.exports = {
+      registerDevice,
+      generateFingerprint,
+      startHeartbeat,
+      DeviceTracker,
+      DeviceStatus,
+      collectDeviceMetadata
+    };
+  }
+});
+
+// src/auction.js
+var require_auction = __commonJS({
+  "src/auction.js"(exports$1, module) {
+    var API_BASE = "https://api.trillboards.com/v1/partner";
+    function parseVast(vastXml) {
+      if (!vastXml || typeof vastXml !== "string") {
+        return null;
+      }
+      let doc;
+      if (typeof DOMParser !== "undefined") {
+        const parser = new DOMParser();
+        doc = parser.parseFromString(vastXml, "text/xml");
+      } else {
+        return {
+          mediaFiles: [],
+          tracking: {},
+          impressionUrls: [],
+          errorUrls: [],
+          raw: vastXml
+        };
+      }
+      const result = {
+        mediaFiles: [],
+        tracking: {},
+        impressionUrls: [],
+        errorUrls: [],
+        clickThrough: null,
+        clickTracking: [],
+        duration: 0
+      };
+      const impressions = doc.querySelectorAll("Impression");
+      impressions.forEach((imp) => {
+        const url = (imp.textContent || "").trim();
+        if (url) result.impressionUrls.push(url);
+      });
+      const errors = doc.querySelectorAll("Error");
+      errors.forEach((err) => {
+        const url = (err.textContent || "").trim();
+        if (url) result.errorUrls.push(url);
+      });
+      const mediaFiles = doc.querySelectorAll("MediaFile");
+      mediaFiles.forEach((mf) => {
+        result.mediaFiles.push({
+          url: (mf.textContent || "").trim(),
+          type: mf.getAttribute("type") || "video/mp4",
+          width: parseInt(mf.getAttribute("width")) || 0,
+          height: parseInt(mf.getAttribute("height")) || 0,
+          bitrate: parseInt(mf.getAttribute("bitrate")) || 0,
+          delivery: mf.getAttribute("delivery") || "progressive"
+        });
+      });
+      const trackingEvents = doc.querySelectorAll("Tracking");
+      trackingEvents.forEach((te) => {
+        const event = te.getAttribute("event");
+        const url = (te.textContent || "").trim();
+        if (event && url) {
+          if (!result.tracking[event]) {
+            result.tracking[event] = [];
+          }
+          result.tracking[event].push(url);
+        }
+      });
+      const clickThrough = doc.querySelector("ClickThrough");
+      if (clickThrough) {
+        result.clickThrough = (clickThrough.textContent || "").trim();
+      }
+      const clickTrackings = doc.querySelectorAll("ClickTracking");
+      clickTrackings.forEach((ct) => {
+        const url = (ct.textContent || "").trim();
+        if (url) result.clickTracking.push(url);
+      });
+      const duration = doc.querySelector("Duration");
+      if (duration) {
+        const timeStr = (duration.textContent || "").trim();
+        const parts = timeStr.split(":");
+        if (parts.length === 3) {
+          result.duration = parseInt(parts[0]) * 3600 + parseInt(parts[1]) * 60 + parseFloat(parts[2]);
+        }
+      }
+      return result;
+    }
+    function firePixel(url) {
+      return new Promise((resolve) => {
+        if (!url) {
+          resolve(false);
+          return;
+        }
+        const separator = url.includes("?") ? "&" : "?";
+        const pixelUrl = `${url}${separator}cb=${Date.now()}`;
+        if (typeof Image !== "undefined") {
+          const img = new Image();
+          img.onload = () => resolve(true);
+          img.onerror = () => resolve(false);
+          img.src = pixelUrl;
+          setTimeout(() => resolve(false), 5e3);
+        } else {
+          fetch(pixelUrl, { method: "GET", mode: "no-cors" }).then(() => resolve(true)).catch(() => resolve(false));
+        }
+      });
+    }
+    async function fetchAds(fingerprint, options = {}) {
+      if (!fingerprint) {
+        throw new Error("fingerprint is required to fetch ads");
+      }
+      const headers = {
+        "Accept": "application/json",
+        "X-SDK-Version": "1.0.0"
+      };
+      if (options.etag) {
+        headers["If-None-Match"] = options.etag;
+      }
+      const response = await fetch(`${API_BASE}/device/${encodeURIComponent(fingerprint)}/ads`, {
+        method: "GET",
+        headers
+      });
+      if (response.status === 304) {
+        return { ads: [], unchanged: true, etag: options.etag };
+      }
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const err = new Error(errorData.message || `Failed to fetch ads: ${response.status}`);
+        err.statusCode = response.status;
+        throw err;
+      }
+      const data = await response.json();
+      return {
+        ads: data.ads || [],
+        settings: data.settings || {},
+        cache_until: data.cache_until,
+        etag: data.etag || null,
+        device: data.device || {},
+        unchanged: false
+      };
+    }
+    function renderAd(ad, container, options = {}) {
+      if (!ad || !ad.url) {
+        throw new Error("Valid ad object with url is required");
+      }
+      const containerEl = typeof container === "string" ? document.querySelector(container) : container;
+      if (!containerEl) {
+        throw new Error("Container element not found");
+      }
+      const muted = options.muted !== false;
+      const autoplay = options.autoplay !== false;
+      const objectFit = options.objectFit || "cover";
+      const onStart = options.onStart || (() => {
+      });
+      const onComplete = options.onComplete || (() => {
+      });
+      const onError = options.onError || (() => {
+      });
+      let element = null;
+      let completionTimer = null;
+      let startTime = null;
+      let destroyed = false;
+      containerEl.innerHTML = "";
+      containerEl.style.position = containerEl.style.position || "relative";
+      containerEl.style.overflow = "hidden";
+      if (ad.type === "video") {
+        element = document.createElement("video");
+        element.src = ad.url;
+        element.muted = muted;
+        element.autoplay = autoplay;
+        element.playsInline = true;
+        element.setAttribute("playsinline", "");
+        element.setAttribute("webkit-playsinline", "");
+        element.style.width = "100%";
+        element.style.height = "100%";
+        element.style.objectFit = objectFit;
+        element.style.display = "block";
+        element.addEventListener("play", () => {
+          if (!destroyed) {
+            startTime = Date.now();
+            onStart({ ad, type: "video", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+          }
+        });
+        element.addEventListener("ended", () => {
+          if (!destroyed) {
+            onComplete({
+              ad,
+              type: "video",
+              duration: startTime ? (Date.now() - startTime) / 1e3 : 0,
+              completed: true,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        });
+        element.addEventListener("error", (e) => {
+          if (!destroyed) {
+            onError({
+              ad,
+              type: "video",
+              error: e.message || "Video playback error",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        });
+        containerEl.appendChild(element);
+      } else {
+        element = document.createElement("img");
+        element.src = ad.url;
+        element.alt = ad.title || "Advertisement";
+        element.style.width = "100%";
+        element.style.height = "100%";
+        element.style.objectFit = objectFit;
+        element.style.display = "block";
+        element.addEventListener("load", () => {
+          if (!destroyed) {
+            startTime = Date.now();
+            onStart({ ad, type: "image", timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+            const duration = (ad.duration || options.imageDuration || 8) * 1e3;
+            completionTimer = setTimeout(() => {
+              if (!destroyed) {
+                onComplete({
+                  ad,
+                  type: "image",
+                  duration: ad.duration || options.imageDuration || 8,
+                  completed: true,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              }
+            }, duration);
+          }
+        });
+        element.addEventListener("error", () => {
+          if (!destroyed) {
+            onError({
+              ad,
+              type: "image",
+              error: "Image failed to load",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        });
+        containerEl.appendChild(element);
+      }
+      return {
+        pause() {
+          if (element && element.pause) {
+            element.pause();
+          }
+        },
+        resume() {
+          if (element && element.play) {
+            element.play().catch(() => {
+            });
+          }
+        },
+        destroy() {
+          destroyed = true;
+          if (completionTimer) {
+            clearTimeout(completionTimer);
+            completionTimer = null;
+          }
+          if (element) {
+            if (element.pause) element.pause();
+            if (element.parentNode) element.parentNode.removeChild(element);
+            element = null;
+          }
+        },
+        getPlaybackState() {
+          if (!element) return { state: "destroyed" };
+          if (ad.type === "video") {
+            return {
+              state: element.paused ? "paused" : "playing",
+              currentTime: element.currentTime,
+              duration: element.duration,
+              muted: element.muted
+            };
+          }
+          return {
+            state: startTime ? "showing" : "loading",
+            elapsed: startTime ? (Date.now() - startTime) / 1e3 : 0
+          };
+        }
+      };
+    }
+    async function trackImpression(ad, fingerprint, options = {}) {
+      if (!ad || !ad.id) {
+        throw new Error("Valid ad object with id is required");
+      }
+      const results = {
+        impression_url: false,
+        pixel_url: false,
+        vast_impressions: []
+      };
+      if (ad.impression_url) {
+        try {
+          const url = new URL(ad.impression_url);
+          if (options.duration) url.searchParams.set("duration", String(options.duration));
+          if (options.completed !== void 0) url.searchParams.set("completed", String(options.completed));
+          const response = await fetch(url.toString(), {
+            method: "GET",
+            mode: "no-cors"
+          });
+          results.impression_url = true;
+        } catch (err) {
+          results.impression_url = false;
+        }
+      }
+      if (ad.pixel_url) {
+        results.pixel_url = await firePixel(ad.pixel_url);
+      }
+      if (ad.vast_data && ad.vast_data.impressionUrls) {
+        for (const vastUrl of ad.vast_data.impressionUrls) {
+          const fired = await firePixel(vastUrl);
+          results.vast_impressions.push({ url: vastUrl, fired });
+        }
+      }
+      return results;
+    }
+    function createAdRotation(config) {
+      if (!config.fingerprint) {
+        throw new Error("fingerprint is required for ad rotation");
+      }
+      const intervalSeconds = config.intervalSeconds || 60;
+      const refreshMinutes = config.refreshMinutes || 5;
+      const onAdStart = config.onAdStart || (() => {
+      });
+      const onAdComplete = config.onAdComplete || (() => {
+      });
+      const onError = config.onError || (() => {
+      });
+      const onImpression = config.onImpression || (() => {
+      });
+      let ads = [];
+      let settings = {};
+      let currentIndex = 0;
+      let currentController = null;
+      let rotationTimer = null;
+      let refreshTimer = null;
+      let running = false;
+      let etag = null;
+      let totalAdsShown = 0;
+      let totalImpressions = 0;
+      async function loadAds() {
+        try {
+          const result = await fetchAds(config.fingerprint, { etag });
+          if (!result.unchanged) {
+            ads = result.ads;
+            settings = result.settings || {};
+            etag = result.etag;
+            currentIndex = 0;
+          }
+          return ads;
+        } catch (err) {
+          onError({ phase: "fetch", error: err.message });
+          return ads;
+        }
+      }
+      function getNextAd() {
+        if (ads.length === 0) return null;
+        const ad = ads[currentIndex % ads.length];
+        currentIndex = (currentIndex + 1) % ads.length;
+        return ad;
+      }
+      async function showNextAd() {
+        if (!running) return;
+        if (currentController) {
+          currentController.destroy();
+          currentController = null;
+        }
+        const ad = getNextAd();
+        if (!ad) {
+          rotationTimer = setTimeout(showNextAd, intervalSeconds * 1e3);
+          return;
+        }
+        try {
+          currentController = renderAd(ad, config.container, {
+            muted: config.muted !== false,
+            autoplay: true,
+            objectFit: config.objectFit || "cover",
+            imageDuration: settings.image_duration || ad.duration || 8,
+            onStart: (data) => {
+              totalAdsShown++;
+              onAdStart({ ...data, totalAdsShown });
+              trackImpression(ad, config.fingerprint, {
+                duration: ad.duration,
+                completed: false
+              }).then((result) => {
+                totalImpressions++;
+                onImpression({ ad, result, totalImpressions });
+              }).catch((err) => {
+                onError({ phase: "impression", error: err.message });
+              });
+              if (config.analytics) {
+                config.analytics.track("ad_start", {
+                  ad_id: ad.id,
+                  ad_type: ad.type,
+                  fingerprint: config.fingerprint
+                });
+              }
+            },
+            onComplete: (data) => {
+              onAdComplete({ ...data, totalAdsShown });
+              if (config.analytics) {
+                config.analytics.track("ad_complete", {
+                  ad_id: ad.id,
+                  ad_type: ad.type,
+                  duration: data.duration,
+                  fingerprint: config.fingerprint
+                });
+              }
+              const waitTime = ad.type === "video" ? 0 : 0;
+              rotationTimer = setTimeout(showNextAd, waitTime);
+            },
+            onError: (data) => {
+              onError({ ...data, phase: "render" });
+              if (config.analytics) {
+                config.analytics.track("error", {
+                  ad_id: ad.id,
+                  error: data.error,
+                  fingerprint: config.fingerprint
+                });
+              }
+              rotationTimer = setTimeout(showNextAd, 2e3);
+            }
+          });
+          if (ad.type !== "video") {
+            const displayTime = (ad.duration || settings.image_duration || 8) * 1e3;
+            rotationTimer = setTimeout(showNextAd, displayTime);
+          }
+        } catch (err) {
+          onError({ phase: "render", error: err.message, ad });
+          rotationTimer = setTimeout(showNextAd, 5e3);
+        }
+      }
+      function start() {
+        if (running) return;
+        running = true;
+        loadAds().then(() => {
+          showNextAd();
+        });
+        refreshTimer = setInterval(async () => {
+          await loadAds();
+        }, refreshMinutes * 60 * 1e3);
+      }
+      function stop() {
+        running = false;
+        if (rotationTimer) {
+          clearTimeout(rotationTimer);
+          rotationTimer = null;
+        }
+        if (refreshTimer) {
+          clearInterval(refreshTimer);
+          refreshTimer = null;
+        }
+        if (currentController) {
+          currentController.destroy();
+          currentController = null;
+        }
+      }
+      function next() {
+        if (!running) return;
+        if (rotationTimer) {
+          clearTimeout(rotationTimer);
+          rotationTimer = null;
+        }
+        showNextAd();
+      }
+      function getStatus() {
+        return {
+          running,
+          totalAds: ads.length,
+          currentIndex,
+          totalAdsShown,
+          totalImpressions,
+          intervalSeconds,
+          settings,
+          etag
+        };
+      }
+      return {
+        start,
+        stop,
+        next,
+        getStatus,
+        loadAds
+      };
+    }
+    module.exports = {
+      fetchAds,
+      renderAd,
+      trackImpression,
+      parseVast,
+      firePixel,
+      createAdRotation
+    };
+  }
+});
+
+// src/offline.js
+var require_offline = __commonJS({
+  "src/offline.js"(exports$1, module) {
+    var DB_NAME = "trillboards_connect";
+    var DB_VERSION = 1;
+    var AD_STORE = "cached_ads";
+    var IMPRESSION_STORE = "queued_impressions";
+    var META_STORE = "metadata";
+    var API_BASE = "https://api.trillboards.com/v1/partner";
+    function openDatabase() {
+      return new Promise((resolve, reject) => {
+        if (typeof indexedDB === "undefined") {
+          reject(new Error("IndexedDB is not available in this environment"));
+          return;
+        }
+        const request = indexedDB.open(DB_NAME, DB_VERSION);
+        request.onupgradeneeded = (event) => {
+          const db = event.target.result;
+          if (!db.objectStoreNames.contains(AD_STORE)) {
+            const adStore = db.createObjectStore(AD_STORE, { keyPath: "id" });
+            adStore.createIndex("fingerprint", "fingerprint", { unique: false });
+            adStore.createIndex("cached_at", "cached_at", { unique: false });
+            adStore.createIndex("expires_at", "expires_at", { unique: false });
+          }
+          if (!db.objectStoreNames.contains(IMPRESSION_STORE)) {
+            const impStore = db.createObjectStore(IMPRESSION_STORE, { keyPath: "queue_id", autoIncrement: true });
+            impStore.createIndex("timestamp", "timestamp", { unique: false });
+            impStore.createIndex("synced", "synced", { unique: false });
+          }
+          if (!db.objectStoreNames.contains(META_STORE)) {
+            db.createObjectStore(META_STORE, { keyPath: "key" });
+          }
+        };
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+      });
+    }
+    async function cacheAds(fingerprint, ads, maxCacheSize = 10) {
+      if (!ads || !Array.isArray(ads) || ads.length === 0) return 0;
+      const now = /* @__PURE__ */ new Date();
+      const expiresAt = new Date(now.getTime() + 24 * 60 * 60 * 1e3);
+      const adsToCache = ads.slice(0, maxCacheSize).map((ad) => ({
+        ...ad,
+        fingerprint,
+        cached_at: now.toISOString(),
+        expires_at: expiresAt.toISOString()
+      }));
+      const db = await openDatabase();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(AD_STORE, "readwrite");
+        const store = tx.objectStore(AD_STORE);
+        let count = 0;
+        for (const ad of adsToCache) {
+          const req = store.put(ad);
+          req.onsuccess = () => count++;
+        }
+        tx.oncomplete = () => {
+          db.close();
+          resolve(count);
+        };
+        tx.onerror = () => {
+          db.close();
+          reject(tx.error);
+        };
+      });
+    }
+    async function getCachedAds(fingerprint) {
+      const db = await openDatabase();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(AD_STORE, "readonly");
+        const store = tx.objectStore(AD_STORE);
+        const index = store.index("fingerprint");
+        const request = index.getAll(fingerprint);
+        request.onsuccess = () => {
+          const now = (/* @__PURE__ */ new Date()).toISOString();
+          const valid = (request.result || []).filter((ad) => ad.expires_at > now);
+          db.close();
+          resolve(valid);
+        };
+        request.onerror = () => {
+          db.close();
+          reject(request.error);
+        };
+      });
+    }
+    async function clearExpiredAds() {
+      const db = await openDatabase();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(AD_STORE, "readwrite");
+        const store = tx.objectStore(AD_STORE);
+        const index = store.index("expires_at");
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const range = IDBKeyRange.upperBound(now);
+        const request = index.openCursor(range);
+        let removed = 0;
+        request.onsuccess = (event) => {
+          const cursor = event.target.result;
+          if (cursor) {
+            cursor.delete();
+            removed++;
+            cursor.continue();
+          }
+        };
+        tx.oncomplete = () => {
+          db.close();
+          resolve(removed);
+        };
+        tx.onerror = () => {
+          db.close();
+          reject(tx.error);
+        };
+      });
+    }
+    async function queueImpression(impressionData) {
+      if (!impressionData || !impressionData.adid) {
+        throw new Error("impressionData with adid is required");
+      }
+      const entry = {
+        ...impressionData,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        synced: false,
+        retry_count: 0
+      };
+      const db = await openDatabase();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(IMPRESSION_STORE, "readwrite");
+        const store = tx.objectStore(IMPRESSION_STORE);
+        const request = store.add(entry);
+        let queueId;
+        request.onsuccess = () => {
+          queueId = request.result;
+        };
+        tx.oncomplete = () => {
+          db.close();
+          resolve(queueId);
+        };
+        tx.onerror = () => {
+          db.close();
+          reject(tx.error);
+        };
+      });
+    }
+    async function getUnsyncedImpressions(limit = 100) {
+      const db = await openDatabase();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(IMPRESSION_STORE, "readonly");
+        const store = tx.objectStore(IMPRESSION_STORE);
+        const index = store.index("synced");
+        const request = index.getAll(false, limit);
+        request.onsuccess = () => {
+          db.close();
+          resolve(request.result || []);
+        };
+        request.onerror = () => {
+          db.close();
+          reject(request.error);
+        };
+      });
+    }
+    async function markSynced(queueIds) {
+      if (!queueIds || queueIds.length === 0) return 0;
+      const db = await openDatabase();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(IMPRESSION_STORE, "readwrite");
+        const store = tx.objectStore(IMPRESSION_STORE);
+        let count = 0;
+        for (const id of queueIds) {
+          const getReq = store.get(id);
+          getReq.onsuccess = () => {
+            const entry = getReq.result;
+            if (entry) {
+              entry.synced = true;
+              entry.synced_at = (/* @__PURE__ */ new Date()).toISOString();
+              store.put(entry);
+              count++;
+            }
+          };
+        }
+        tx.oncomplete = () => {
+          db.close();
+          resolve(count);
+        };
+        tx.onerror = () => {
+          db.close();
+          reject(tx.error);
+        };
+      });
+    }
+    async function purgeSyncedImpressions(maxAgeHours = 72) {
+      const cutoff = new Date(Date.now() - maxAgeHours * 60 * 60 * 1e3).toISOString();
+      const db = await openDatabase();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(IMPRESSION_STORE, "readwrite");
+        const store = tx.objectStore(IMPRESSION_STORE);
+        const request = store.openCursor();
+        let removed = 0;
+        request.onsuccess = (event) => {
+          const cursor = event.target.result;
+          if (cursor) {
+            const entry = cursor.value;
+            if (entry.synced && entry.timestamp < cutoff) {
+              cursor.delete();
+              removed++;
+            }
+            cursor.continue();
+          }
+        };
+        tx.oncomplete = () => {
+          db.close();
+          resolve(removed);
+        };
+        tx.onerror = () => {
+          db.close();
+          reject(tx.error);
+        };
+      });
+    }
+    async function syncImpressions(options = {}) {
+      const batchSize = options.batchSize || 50;
+      const onProgress = options.onProgress || (() => {
+      });
+      const onError = options.onError || (() => {
+      });
+      const results = {
+        total: 0,
+        synced: 0,
+        failed: 0,
+        batches: 0
+      };
+      const unsynced = await getUnsyncedImpressions(100);
+      results.total = unsynced.length;
+      if (unsynced.length === 0) {
+        return results;
+      }
+      for (let i = 0; i < unsynced.length; i += batchSize) {
+        const batch = unsynced.slice(i, i + batchSize);
+        const impressions = batch.map((entry) => ({
+          adid: entry.adid,
+          impid: entry.impid,
+          did: entry.did,
+          device_fingerprint: entry.device_fingerprint,
+          aid: entry.aid,
+          sid: entry.sid,
+          duration: entry.duration,
+          completed: entry.completed,
+          timestamp: entry.timestamp
+        }));
+        try {
+          const response = await fetch(`${API_BASE}/impressions/batch`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "X-SDK-Version": "1.0.0"
+            },
+            body: JSON.stringify({ impressions })
+          });
+          if (response.ok) {
+            const data = await response.json();
+            const syncedIds = batch.map((entry) => entry.queue_id);
+            await markSynced(syncedIds);
+            results.synced += data.recorded || batch.length;
+            results.failed += data.failed || 0;
+          } else {
+            results.failed += batch.length;
+            onError({
+              batch: results.batches,
+              status: response.status,
+              count: batch.length
+            });
+          }
+        } catch (err) {
+          results.failed += batch.length;
+          onError({
+            batch: results.batches,
+            error: err.message,
+            count: batch.length
+          });
+        }
+        results.batches++;
+        onProgress({
+          processed: Math.min(i + batchSize, unsynced.length),
+          total: unsynced.length,
+          synced: results.synced,
+          failed: results.failed
+        });
+      }
+      await purgeSyncedImpressions(72).catch(() => {
+      });
+      return results;
+    }
+    function createAutoSync(options = {}) {
+      const syncIntervalMs = options.syncIntervalMs || 5 * 60 * 1e3;
+      const onSyncComplete = options.onSyncComplete || (() => {
+      });
+      const onStatusChange = options.onStatusChange || (() => {
+      });
+      let intervalId = null;
+      let running = false;
+      let syncing = false;
+      async function doSync() {
+        if (syncing) return;
+        syncing = true;
+        try {
+          const isOnline = typeof navigator !== "undefined" ? navigator.onLine : true;
+          if (!isOnline) {
+            syncing = false;
+            return;
+          }
+          const result = await syncImpressions({
+            batchSize: 50,
+            onError: (err) => {
+              console.warn("[Trillboards SDK] Sync batch error:", err);
+            }
+          });
+          onSyncComplete(result);
+        } catch (err) {
+          console.error("[Trillboards SDK] Auto-sync error:", err);
+        } finally {
+          syncing = false;
+        }
+      }
+      function handleOnline() {
+        onStatusChange({ online: true, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        doSync();
+      }
+      function handleOffline() {
+        onStatusChange({ online: false, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      }
+      function start() {
+        if (running) return;
+        running = true;
+        if (typeof window !== "undefined") {
+          window.addEventListener("online", handleOnline);
+          window.addEventListener("offline", handleOffline);
+        }
+        intervalId = setInterval(doSync, syncIntervalMs);
+        doSync();
+      }
+      function stop() {
+        running = false;
+        if (typeof window !== "undefined") {
+          window.removeEventListener("online", handleOnline);
+          window.removeEventListener("offline", handleOffline);
+        }
+        if (intervalId) {
+          clearInterval(intervalId);
+          intervalId = null;
+        }
+      }
+      function getStatus() {
+        return {
+          running,
+          syncing,
+          online: typeof navigator !== "undefined" ? navigator.onLine : true
+        };
+      }
+      return {
+        start,
+        stop,
+        sync: doSync,
+        getStatus
+      };
+    }
+    module.exports = {
+      // Database operations
+      openDatabase,
+      // Ad cache
+      cacheAds,
+      getCachedAds,
+      clearExpiredAds,
+      // Impression queue
+      queueImpression,
+      getUnsyncedImpressions,
+      markSynced,
+      purgeSyncedImpressions,
+      syncImpressions,
+      // Auto-sync
+      createAutoSync
+    };
+  }
+});
+
+// src/branding.js
+var require_branding = __commonJS({
+  "src/branding.js"(exports$1, module) {
+    var DEFAULT_BRANDING_ID = "trillboards-connect-branding";
+    var CUSTOM_CSS_ID = "trillboards-connect-custom-css";
+    var DEFAULT_CSS = `
+/* Trillboards Connect SDK - Default Branding */
+.trillboards-container {
+    position: relative;
+    width: 100%;
+    height: 100%;
+    overflow: hidden;
+    background-color: #000000;
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
+}
+
+.trillboards-container video,
+.trillboards-container img {
+    width: 100%;
+    height: 100%;
+    object-fit: cover;
+    display: block;
+}
+
+.trillboards-overlay {
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    right: 0;
+    padding: 8px 16px;
+    background: linear-gradient(transparent, rgba(0, 0, 0, 0.7));
+    color: #ffffff;
+    font-size: 12px;
+    opacity: 0;
+    transition: opacity 0.3s ease;
+    pointer-events: none;
+}
+
+.trillboards-container:hover .trillboards-overlay {
+    opacity: 1;
+}
+
+.trillboards-badge {
+    position: absolute;
+    top: 8px;
+    right: 8px;
+    background: rgba(0, 0, 0, 0.5);
+    color: #ffffff;
+    font-size: 10px;
+    padding: 2px 6px;
+    border-radius: 4px;
+    opacity: 0.6;
+    transition: opacity 0.3s ease;
+    pointer-events: none;
+    z-index: 10;
+}
+
+.trillboards-badge:hover {
+    opacity: 1;
+}
+
+.trillboards-loading {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    width: 40px;
+    height: 40px;
+    border: 3px solid rgba(255, 255, 255, 0.2);
+    border-top: 3px solid #ffffff;
+    border-radius: 50%;
+    animation: trillboards-spin 1s linear infinite;
+}
+
+@keyframes trillboards-spin {
+    0% { transform: translate(-50%, -50%) rotate(0deg); }
+    100% { transform: translate(-50%, -50%) rotate(360deg); }
+}
+
+.trillboards-error {
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    color: #999999;
+    font-size: 14px;
+    text-align: center;
+}
+
+.trillboards-skip-btn {
+    position: absolute;
+    bottom: 16px;
+    right: 16px;
+    background: rgba(255, 255, 255, 0.15);
+    color: #ffffff;
+    border: 1px solid rgba(255, 255, 255, 0.3);
+    padding: 8px 16px;
+    font-size: 12px;
+    border-radius: 4px;
+    cursor: pointer;
+    transition: background 0.2s ease;
+    z-index: 10;
+}
+
+.trillboards-skip-btn:hover {
+    background: rgba(255, 255, 255, 0.25);
+}
+`;
+    function injectDefaultBranding() {
+      if (typeof document === "undefined") return null;
+      if (document.getElementById(DEFAULT_BRANDING_ID)) {
+        return document.getElementById(DEFAULT_BRANDING_ID);
+      }
+      const style = document.createElement("style");
+      style.id = DEFAULT_BRANDING_ID;
+      style.type = "text/css";
+      style.textContent = DEFAULT_CSS;
+      document.head.appendChild(style);
+      return style;
+    }
+    async function loadCustomCss(cssUrl, options = {}) {
+      if (typeof document === "undefined") return null;
+      if (!cssUrl || typeof cssUrl !== "string") {
+        return null;
+      }
+      const timeout = options.timeout || 5e3;
+      const onLoad = options.onLoad || (() => {
+      });
+      const onError = options.onError || (() => {
+      });
+      const existing = document.getElementById(CUSTOM_CSS_ID);
+      if (existing) {
+        existing.parentNode.removeChild(existing);
+      }
+      return new Promise((resolve) => {
+        const link = document.createElement("link");
+        link.id = CUSTOM_CSS_ID;
+        link.rel = "stylesheet";
+        link.type = "text/css";
+        link.href = cssUrl;
+        const timer = setTimeout(() => {
+          onError({ error: "CSS load timeout", url: cssUrl });
+          resolve(null);
+        }, timeout);
+        link.onload = () => {
+          clearTimeout(timer);
+          onLoad({ url: cssUrl });
+          resolve(link);
+        };
+        link.onerror = () => {
+          clearTimeout(timer);
+          onError({ error: "CSS load failed", url: cssUrl });
+          resolve(null);
+        };
+        document.head.appendChild(link);
+      });
+    }
+    function removeBranding() {
+      if (typeof document === "undefined") return;
+      const defaultStyle = document.getElementById(DEFAULT_BRANDING_ID);
+      if (defaultStyle) defaultStyle.parentNode.removeChild(defaultStyle);
+      const customLink = document.getElementById(CUSTOM_CSS_ID);
+      if (customLink) customLink.parentNode.removeChild(customLink);
+    }
+    async function applyBranding(sdkConfig = {}) {
+      const state = {
+        defaultApplied: false,
+        customApplied: false,
+        customUrl: null
+      };
+      const defaultEl = injectDefaultBranding();
+      state.defaultApplied = !!defaultEl;
+      if (sdkConfig.custom_css_url) {
+        state.customUrl = sdkConfig.custom_css_url;
+        const customEl = await loadCustomCss(sdkConfig.custom_css_url);
+        state.customApplied = !!customEl;
+      }
+      return state;
+    }
+    module.exports = {
+      injectDefaultBranding,
+      loadCustomCss,
+      removeBranding,
+      applyBranding,
+      DEFAULT_CSS
+    };
+  }
+});
+
+// src/analytics.js
+var require_analytics = __commonJS({
+  "src/analytics.js"(exports$1, module) {
+    var API_BASE = "https://api.trillboards.com/v1/partner";
+    var EventTypes = {
+      AD_START: "ad_start",
+      AD_COMPLETE: "ad_complete",
+      AD_SKIP: "ad_skip",
+      AD_ERROR: "ad_error",
+      ERROR: "error",
+      HEARTBEAT: "heartbeat",
+      SDK_INIT: "sdk_init",
+      SDK_ERROR: "sdk_error",
+      DEVICE_REGISTERED: "device_registered",
+      OFFLINE_SYNC: "offline_sync",
+      AD_IMPRESSION: "ad_impression",
+      VISIBILITY_CHANGE: "visibility_change"
+    };
+    function createAnalytics(config = {}) {
+      const fingerprint = config.fingerprint || "unknown";
+      const apiKey = config.apiKey || null;
+      const flushIntervalMs = config.flushIntervalMs || 3e4;
+      const maxBufferSize = config.maxBufferSize || 50;
+      const onFlush = config.onFlush || (() => {
+      });
+      const onError = config.onError || (() => {
+      });
+      const enabled = config.enabled !== false;
+      let buffer = [];
+      let flushTimer = null;
+      let flushing = false;
+      let running = false;
+      let totalTracked = 0;
+      let totalFlushed = 0;
+      let totalErrors = 0;
+      let sessionId = generateSessionId();
+      function generateSessionId() {
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).substring(2, 8);
+        return `sess_${timestamp}_${random}`;
+      }
+      function track(eventType, data = {}) {
+        if (!enabled || !running) return null;
+        const event = {
+          event: eventType,
+          fingerprint,
+          session_id: sessionId,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data: {
+            ...data,
+            sdk_version: "1.0.0"
+          }
+        };
+        buffer.push(event);
+        totalTracked++;
+        if (buffer.length >= maxBufferSize) {
+          flush();
+        }
+        return event;
+      }
+      async function flush() {
+        if (flushing || buffer.length === 0) {
+          return { flushed: 0, errors: 0 };
+        }
+        flushing = true;
+        const eventsToSend = buffer.splice(0);
+        try {
+          const adEvents = eventsToSend.filter(
+            (e) => [EventTypes.AD_START, EventTypes.AD_COMPLETE, EventTypes.AD_SKIP, EventTypes.AD_IMPRESSION].includes(e.event)
+          );
+          const otherEvents = eventsToSend.filter(
+            (e) => ![EventTypes.AD_START, EventTypes.AD_COMPLETE, EventTypes.AD_SKIP, EventTypes.AD_IMPRESSION].includes(e.event)
+          );
+          let flushed = 0;
+          if (adEvents.length > 0) {
+            const impressions = adEvents.filter((e) => e.data && e.data.ad_id).map((e) => ({
+              adid: e.data.ad_id,
+              impid: e.data.impression_id || `sdk_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`,
+              did: e.fingerprint,
+              device_fingerprint: e.fingerprint,
+              duration: e.data.duration || 0,
+              completed: e.event === EventTypes.AD_COMPLETE,
+              timestamp: e.timestamp
+            }));
+            if (impressions.length > 0) {
+              const headers = {
+                "Content-Type": "application/json",
+                "X-SDK-Version": "1.0.0"
+              };
+              if (apiKey) {
+                headers["Authorization"] = `Bearer ${apiKey}`;
+              }
+              const response = await fetch(`${API_BASE}/impressions/batch`, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({ impressions })
+              });
+              if (response.ok) {
+                flushed += impressions.length;
+              } else {
+                throw new Error(`Batch send failed: ${response.status}`);
+              }
+            }
+            flushed += adEvents.length - adEvents.filter((e) => e.data && e.data.ad_id).length;
+          }
+          flushed += otherEvents.length;
+          totalFlushed += flushed;
+          const result = { flushed, errors: 0, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+          onFlush(result);
+          return result;
+        } catch (err) {
+          totalErrors++;
+          buffer.unshift(...eventsToSend);
+          if (buffer.length > maxBufferSize * 3) {
+            buffer = buffer.slice(-maxBufferSize * 2);
+          }
+          const errorResult = { flushed: 0, errors: eventsToSend.length, error: err.message };
+          onError(errorResult);
+          return errorResult;
+        } finally {
+          flushing = false;
+        }
+      }
+      function start() {
+        if (running) return;
+        running = true;
+        sessionId = generateSessionId();
+        flushTimer = setInterval(() => {
+          flush();
+        }, flushIntervalMs);
+        if (typeof window !== "undefined") {
+          window.addEventListener("beforeunload", handleBeforeUnload);
+          document.addEventListener("visibilitychange", handleVisibilityChange);
+        }
+        track(EventTypes.SDK_INIT, {
+          fingerprint,
+          flush_interval_ms: flushIntervalMs,
+          max_buffer_size: maxBufferSize
+        });
+      }
+      async function stop() {
+        running = false;
+        if (flushTimer) {
+          clearInterval(flushTimer);
+          flushTimer = null;
+        }
+        if (typeof window !== "undefined") {
+          window.removeEventListener("beforeunload", handleBeforeUnload);
+          document.removeEventListener("visibilitychange", handleVisibilityChange);
+        }
+        await flush();
+      }
+      function handleBeforeUnload() {
+        if (buffer.length > 0 && typeof navigator !== "undefined" && navigator.sendBeacon) {
+          const adEvents = buffer.filter((e) => e.data && e.data.ad_id);
+          if (adEvents.length > 0) {
+            const impressions = adEvents.map((e) => ({
+              adid: e.data.ad_id,
+              impid: e.data.impression_id || `sdk_${Date.now()}_${Math.random().toString(36).substr(2, 6)}`,
+              did: e.fingerprint,
+              duration: e.data.duration || 0,
+              completed: e.event === EventTypes.AD_COMPLETE,
+              timestamp: e.timestamp
+            }));
+            const blob = new Blob(
+              [JSON.stringify({ impressions })],
+              { type: "application/json" }
+            );
+            navigator.sendBeacon(`${API_BASE}/impressions/batch`, blob);
+          }
+          buffer = [];
+        }
+      }
+      function handleVisibilityChange() {
+        if (document.visibilityState === "hidden") {
+          track(EventTypes.VISIBILITY_CHANGE, { visible: false });
+          flush();
+        } else {
+          track(EventTypes.VISIBILITY_CHANGE, { visible: true });
+        }
+      }
+      function getStats() {
+        return {
+          running,
+          enabled,
+          sessionId,
+          bufferSize: buffer.length,
+          totalTracked,
+          totalFlushed,
+          totalErrors,
+          fingerprint
+        };
+      }
+      async function destroy() {
+        await stop();
+        buffer = [];
+        totalTracked = 0;
+        totalFlushed = 0;
+        totalErrors = 0;
+      }
+      return {
+        track,
+        flush,
+        start,
+        stop,
+        destroy,
+        getStats,
+        EventTypes
+      };
+    }
+    module.exports = {
+      createAnalytics,
+      EventTypes
+    };
+  }
+});
+
+// src/index.js
+var require_src = __commonJS({
+  "src/index.js"(exports$1, module) {
+    var { DeviceTracker, DeviceStatus, generateFingerprint, registerDevice, startHeartbeat } = require_device();
+    var { fetchAds, renderAd, trackImpression, parseVast, createAdRotation } = require_auction();
+    var { cacheAds, getCachedAds, queueImpression, syncImpressions, createAutoSync, clearExpiredAds } = require_offline();
+    var { applyBranding, injectDefaultBranding, loadCustomCss, removeBranding } = require_branding();
+    var { createAnalytics, EventTypes } = require_analytics();
+    var SDK_VERSION = "1.0.0";
+    var API_BASE = "https://api.trillboards.com/v1/partner";
+    function validateConfig(config) {
+      if (!config) {
+        throw new Error("TrillboardsConnect.init() requires a configuration object");
+      }
+      if (!config.apiKey) {
+        throw new Error("apiKey is required. Get your API key from https://trillboards.com/earner");
+      }
+      if (!config.deviceId) {
+        throw new Error("deviceId is required. Provide a unique identifier for this device.");
+      }
+    }
+    function resolveContainer(containerId) {
+      if (!containerId) return null;
+      if (typeof containerId === "string") {
+        return typeof document !== "undefined" ? document.getElementById(containerId) : null;
+      }
+      return containerId;
+    }
+    var ConnectInstance = class {
+      constructor(config) {
+        this.config = config;
+        this.apiKey = config.apiKey;
+        this.deviceId = config.deviceId;
+        this.containerId = config.containerId;
+        this.options = config.options || {};
+        this.deviceTracker = null;
+        this.adRotation = null;
+        this.autoSync = null;
+        this.analytics = null;
+        this.socketConnection = null;
+        this.initialized = false;
+        this.destroyed = false;
+        this.fingerprint = null;
+        this.screenId = null;
+        this.embedUrl = null;
+        this.sdkConfig = null;
+        this._listeners = {};
+      }
+      /**
+       * Register an event listener.
+       *
+       * @param {string} event - Event name
+       * @param {Function} callback - Event handler
+       * @returns {ConnectInstance} This instance for chaining
+       */
+      on(event, callback) {
+        if (!this._listeners[event]) {
+          this._listeners[event] = [];
+        }
+        this._listeners[event].push(callback);
+        return this;
+      }
+      /**
+       * Remove an event listener.
+       *
+       * @param {string} event - Event name
+       * @param {Function} callback - Handler to remove
+       * @returns {ConnectInstance} This instance for chaining
+       */
+      off(event, callback) {
+        if (this._listeners[event]) {
+          this._listeners[event] = this._listeners[event].filter((cb) => cb !== callback);
+        }
+        return this;
+      }
+      /**
+       * Emit an event to all registered listeners.
+       *
+       * @param {string} event - Event name
+       * @param {Object} data - Event data
+       */
+      _emit(event, data) {
+        if (this._listeners[event]) {
+          this._listeners[event].forEach((cb) => {
+            try {
+              cb(data);
+            } catch (err) {
+              console.error(`[Trillboards SDK] Listener error for '${event}':`, err);
+            }
+          });
+        }
+      }
+      /**
+       * Initialize the SDK: register device, start heartbeat, set up ad rotation.
+       *
+       * @returns {Promise<ConnectInstance>} This instance
+       */
+      async initialize() {
+        if (this.initialized) {
+          console.warn("[Trillboards SDK] Already initialized");
+          return this;
+        }
+        this._emit("initializing", { deviceId: this.deviceId, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        if (this.options.analytics !== false) {
+          const tempFingerprint = generateFingerprint(this.deviceId);
+          this.analytics = createAnalytics({
+            fingerprint: tempFingerprint,
+            apiKey: this.apiKey,
+            flushIntervalMs: this.options.analyticsFlushInterval || 3e4,
+            maxBufferSize: this.options.analyticsBufferSize || 50,
+            onFlush: (result) => {
+              this._emit("analytics_flush", result);
+            },
+            onError: (err) => {
+              this._emit("analytics_error", err);
+            }
+          });
+          this.analytics.start();
+        }
+        this.deviceTracker = new DeviceTracker(this.deviceId);
+        this.deviceTracker.on("status_change", (data) => this._emit("device_status", data));
+        this.deviceTracker.on("registered", (data) => this._emit("device_registered", data));
+        this.deviceTracker.on("error", (data) => this._emit("device_error", data));
+        this.deviceTracker.on("heartbeat", (data) => this._emit("heartbeat", data));
+        this.deviceTracker.on("heartbeat_error", (data) => this._emit("heartbeat_error", data));
+        try {
+          const registrationResult = await this.deviceTracker.register(this.apiKey, {
+            device_type: this.options.deviceType || "digital_signage",
+            name: this.options.deviceName || `SDK Device: ${this.deviceId}`,
+            display: this.options.display,
+            location: this.options.location,
+            custom: {
+              sdk_version: SDK_VERSION,
+              ...this.options.metadata || {}
+            }
+          }, {
+            interval: this.options.heartbeatInterval || 6e4,
+            maxRetries: this.options.heartbeatMaxRetries || 10,
+            retryBackoff: 1.5
+          });
+          this.fingerprint = registrationResult.fingerprint;
+          this.screenId = registrationResult.screen_id;
+          this.embedUrl = registrationResult.embed_url;
+          if (this.analytics) {
+            this.analytics.destroy();
+            this.analytics = createAnalytics({
+              fingerprint: this.fingerprint,
+              apiKey: this.apiKey,
+              flushIntervalMs: this.options.analyticsFlushInterval || 3e4,
+              maxBufferSize: this.options.analyticsBufferSize || 50,
+              onFlush: (result) => this._emit("analytics_flush", result),
+              onError: (err) => this._emit("analytics_error", err)
+            });
+            this.analytics.start();
+            this.analytics.track(EventTypes.DEVICE_REGISTERED, {
+              fingerprint: this.fingerprint,
+              screen_id: this.screenId
+            });
+          }
+        } catch (err) {
+          this._emit("error", {
+            phase: "device_registration",
+            error: err.message,
+            statusCode: err.statusCode
+          });
+          if (this.analytics) {
+            this.analytics.track(EventTypes.SDK_ERROR, {
+              phase: "device_registration",
+              error: err.message
+            });
+          }
+          throw err;
+        }
+        try {
+          const infoResponse = await fetch(`${API_BASE}/info`, {
+            headers: {
+              "Authorization": `Bearer ${this.apiKey}`,
+              "X-SDK-Version": SDK_VERSION
+            }
+          });
+          if (infoResponse.ok) {
+            const partnerInfo = await infoResponse.json();
+            this.sdkConfig = partnerInfo.sdk_config || {};
+          }
+        } catch (err) {
+          this.sdkConfig = {};
+        }
+        try {
+          await applyBranding(this.sdkConfig);
+        } catch (err) {
+          console.warn("[Trillboards SDK] Branding error:", err.message);
+        }
+        const container = resolveContainer(this.containerId);
+        if (container && this.fingerprint) {
+          this.adRotation = createAdRotation({
+            fingerprint: this.fingerprint,
+            container,
+            intervalSeconds: this.sdkConfig.ad_interval || this.options.adInterval || 60,
+            refreshMinutes: this.options.adRefreshMinutes || 5,
+            muted: this.options.muted !== false,
+            objectFit: this.options.objectFit || "cover",
+            analytics: this.analytics,
+            onAdStart: (data) => {
+              this._emit("ad_start", data);
+            },
+            onAdComplete: (data) => {
+              this._emit("ad_complete", data);
+            },
+            onError: (data) => {
+              this._emit("ad_error", data);
+            },
+            onImpression: (data) => {
+              this._emit("impression", data);
+            }
+          });
+          this.adRotation.start();
+        }
+        if (this.options.offlineCache !== false && typeof indexedDB !== "undefined") {
+          this.autoSync = createAutoSync({
+            syncIntervalMs: this.options.syncInterval || 5 * 60 * 1e3,
+            onSyncComplete: (result) => {
+              this._emit("sync_complete", result);
+              if (this.analytics) {
+                this.analytics.track(EventTypes.OFFLINE_SYNC, {
+                  synced: result.synced,
+                  failed: result.failed
+                });
+              }
+            },
+            onStatusChange: (status) => {
+              this._emit("connectivity_change", status);
+            }
+          });
+          this.autoSync.start();
+        }
+        this._setupSocket();
+        this.initialized = true;
+        this._emit("ready", {
+          deviceId: this.deviceId,
+          fingerprint: this.fingerprint,
+          screenId: this.screenId,
+          embedUrl: this.embedUrl,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        return this;
+      }
+      /**
+       * Set up Socket.io connection for real-time commands.
+       * Connects to the API's Socket.io endpoint for live updates.
+       */
+      _setupSocket() {
+        const io = typeof window !== "undefined" && window.io ? window.io : null;
+        if (!io || !this.fingerprint) return;
+        try {
+          this.socketConnection = io(API_BASE.replace("/v1/partner", ""), {
+            transports: ["websocket", "polling"],
+            query: {
+              fingerprint: this.fingerprint,
+              sdk_version: SDK_VERSION,
+              type: "partner_sdk"
+            },
+            reconnection: true,
+            reconnectionAttempts: 10,
+            reconnectionDelay: 1e3,
+            reconnectionDelayMax: 3e4
+          });
+          this.socketConnection.on("connect", () => {
+            this._emit("socket_connected", { socketId: this.socketConnection.id });
+            this.socketConnection.emit("join_screen", {
+              fingerprint: this.fingerprint,
+              screen_id: this.screenId
+            });
+          });
+          this.socketConnection.on("disconnect", (reason) => {
+            this._emit("socket_disconnected", { reason });
+          });
+          this.socketConnection.on("refresh_ads", () => {
+            if (this.adRotation) {
+              this.adRotation.loadAds().then(() => {
+                this._emit("ads_refreshed", { source: "socket" });
+              });
+            }
+          });
+          this.socketConnection.on("update_config", (data) => {
+            if (data && data.sdk_config) {
+              this.sdkConfig = { ...this.sdkConfig, ...data.sdk_config };
+              this._emit("config_updated", { config: this.sdkConfig, source: "socket" });
+            }
+          });
+          this.socketConnection.on("force_reload", () => {
+            this._emit("force_reload", { timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+          });
+          this.socketConnection.on("content_update", (data) => {
+            this._emit("content_update", data);
+            if (this.adRotation) {
+              this.adRotation.loadAds();
+            }
+          });
+          this.socketConnection.on("connect_error", (err) => {
+            this._emit("socket_error", { error: err.message });
+          });
+        } catch (err) {
+          console.warn("[Trillboards SDK] Socket.io setup failed:", err.message);
+        }
+      }
+      /**
+       * Manually trigger the next ad in rotation.
+       */
+      nextAd() {
+        if (this.adRotation) {
+          this.adRotation.next();
+        }
+      }
+      /**
+       * Pause ad rotation.
+       */
+      pause() {
+        if (this.adRotation) {
+          this.adRotation.stop();
+        }
+      }
+      /**
+       * Resume ad rotation.
+       */
+      resume() {
+        if (this.adRotation) {
+          this.adRotation.start();
+        }
+      }
+      /**
+       * Get the current state of all subsystems.
+       *
+       * @returns {Object} Complete SDK state
+       */
+      getState() {
+        return {
+          version: SDK_VERSION,
+          initialized: this.initialized,
+          destroyed: this.destroyed,
+          device: this.deviceTracker ? this.deviceTracker.getState() : null,
+          adRotation: this.adRotation ? this.adRotation.getStatus() : null,
+          offlineSync: this.autoSync ? this.autoSync.getStatus() : null,
+          analytics: this.analytics ? this.analytics.getStats() : null,
+          socket: this.socketConnection ? {
+            connected: this.socketConnection.connected,
+            id: this.socketConnection.id
+          } : null,
+          config: this.sdkConfig
+        };
+      }
+      /**
+       * Queue an impression for offline sync.
+       *
+       * @param {Object} impressionData - Impression data
+       * @returns {Promise<number>} Queue ID
+       */
+      async queueOfflineImpression(impressionData) {
+        return queueImpression({
+          ...impressionData,
+          device_fingerprint: this.fingerprint
+        });
+      }
+      /**
+       * Force sync of offline impressions.
+       *
+       * @returns {Promise<Object>} Sync results
+       */
+      async syncOffline() {
+        return syncImpressions({
+          batchSize: 50,
+          onError: (err) => {
+            this._emit("sync_error", err);
+          }
+        });
+      }
+      /**
+       * Cache ads for offline use.
+       *
+       * @param {Array} ads - Array of ad objects
+       * @returns {Promise<number>} Number of ads cached
+       */
+      async cacheAdsOffline(ads) {
+        if (!this.fingerprint) return 0;
+        const maxCache = this.sdkConfig?.cache_size || this.options.cacheSize || 10;
+        return cacheAds(this.fingerprint, ads, maxCache);
+      }
+      /**
+       * Destroy the SDK instance and clean up all resources.
+       */
+      async destroy() {
+        if (this.destroyed) return;
+        this.destroyed = true;
+        this._emit("destroying", { timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+        if (this.adRotation) {
+          this.adRotation.stop();
+          this.adRotation = null;
+        }
+        if (this.socketConnection) {
+          this.socketConnection.disconnect();
+          this.socketConnection = null;
+        }
+        if (this.autoSync) {
+          this.autoSync.stop();
+          this.autoSync = null;
+        }
+        if (this.analytics) {
+          await this.analytics.destroy();
+          this.analytics = null;
+        }
+        if (this.deviceTracker) {
+          this.deviceTracker.destroy();
+          this.deviceTracker = null;
+        }
+        removeBranding();
+        this.initialized = false;
+        this._listeners = {};
+      }
+    };
+    var TrillboardsConnect = {
+      /**
+       * SDK version
+       */
+      version: SDK_VERSION,
+      /**
+       * Initialize the SDK with configuration.
+       *
+       * @param {Object} config - SDK configuration
+       * @param {string} config.apiKey - Partner API key (trb_partner_xxx)
+       * @param {string} config.deviceId - Unique device identifier
+       * @param {string|HTMLElement} config.containerId - DOM container for ad rendering
+       * @param {Object} config.options - Additional options
+       * @param {number} config.options.heartbeatInterval - Heartbeat interval ms (default 60000)
+       * @param {number} config.options.adInterval - Ad rotation interval seconds (default 60)
+       * @param {boolean} config.options.muted - Start ads muted (default true)
+       * @param {boolean} config.options.offlineCache - Enable offline caching (default true)
+       * @param {boolean} config.options.analytics - Enable analytics (default true)
+       * @param {string} config.options.deviceType - Device type (default 'digital_signage')
+       * @param {string} config.options.deviceName - Friendly device name
+       * @param {Object} config.options.display - Display specs { width, height }
+       * @param {Object} config.options.location - Location { lat, lng, address, venue_type }
+       * @param {Object} config.options.metadata - Custom metadata
+       * @returns {ConnectInstance} SDK instance (call .on('ready', ...) for initialization)
+       */
+      init(config) {
+        validateConfig(config);
+        const instance = new ConnectInstance(config);
+        instance.initialize().catch((err) => {
+          console.error("[Trillboards SDK] Initialization failed:", err.message);
+          instance._emit("error", {
+            phase: "init",
+            error: err.message,
+            fatal: true
+          });
+        });
+        return instance;
+      },
+      /**
+       * Create an instance without auto-initialization (for advanced use cases).
+       *
+       * @param {Object} config - SDK configuration
+       * @returns {ConnectInstance} Uninitialized SDK instance
+       */
+      create(config) {
+        validateConfig(config);
+        return new ConnectInstance(config);
+      },
+      // Expose sub-modules for advanced usage
+      device: {
+        register: registerDevice,
+        generateFingerprint,
+        startHeartbeat,
+        DeviceTracker,
+        DeviceStatus
+      },
+      auction: {
+        fetchAds,
+        renderAd,
+        trackImpression,
+        parseVast,
+        createAdRotation
+      },
+      offline: {
+        cacheAds,
+        getCachedAds,
+        queueImpression,
+        syncImpressions,
+        createAutoSync,
+        clearExpiredAds
+      },
+      branding: {
+        applyBranding,
+        injectDefaultBranding,
+        loadCustomCss,
+        removeBranding
+      },
+      analytics: {
+        createAnalytics,
+        EventTypes
+      }
+    };
+    module.exports = TrillboardsConnect;
+    module.exports.TrillboardsConnect = TrillboardsConnect;
+    module.exports.ConnectInstance = ConnectInstance;
+    if (typeof window !== "undefined") {
+      window.TrillboardsConnect = TrillboardsConnect;
+    }
+  }
+});
+var index = require_src();
+
+module.exports = index;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map