@halo-ads/core 0.1.0

package/dist/index.js

@@ -0,0 +1,1079 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/exports.ts
+var exports_exports = {};
+__export(exports_exports, {
+  AdClient: () => AdClient,
+  AdLoader: () => AdLoader,
+  Analytics: () => Analytics,
+  ConsoleAnalyticsProvider: () => ConsoleAnalyticsProvider,
+  DOMRenderer: () => DOMRenderer,
+  EventTracker: () => EventTracker,
+  HaloAds: () => HaloAds,
+  MOCK_ADS: () => MOCK_ADS,
+  MockAdProvider: () => MockAdProvider,
+  ProfileStore: () => ProfileStore,
+  Recommendation: () => Recommendation
+});
+module.exports = __toCommonJS(exports_exports);
+
+// src/AdClient.ts
+var AdClient = class {
+  constructor(provider, publisherId, debug = false) {
+    this.provider = provider;
+    this.publisherId = publisherId;
+    this.debug = debug;
+  }
+  async fetchAd(slot, options) {
+    const request = {
+      slot,
+      publisherId: this.publisherId,
+      ...options
+    };
+    if (this.debug) {
+      console.log(`[Halo Ads] \u{1F4E1} Fetching ad for slot="${slot}"`, request);
+    }
+    try {
+      const response = await this.provider.fetchAd(request);
+      if (!response.fill || !response.ad) {
+        if (this.debug) {
+          console.log(`[Halo Ads] \u26AA No fill for slot="${slot}"`);
+        }
+        return null;
+      }
+      if (this.debug) {
+        console.log(
+          `[Halo Ads] \u2705 Ad selected \u2014 id=${response.ad.id} slot="${slot}"`
+        );
+      }
+      return response.ad;
+    } catch (err) {
+      if (this.debug) {
+        console.error(`[Halo Ads] \u274C Error fetching ad for slot="${slot}":`, err);
+      }
+      return null;
+    }
+  }
+  async fetchMultiple(slots, options) {
+    const results = {};
+    await Promise.all(
+      slots.map(async (slot) => {
+        results[slot] = await this.fetchAd(slot, options);
+      })
+    );
+    return results;
+  }
+};
+
+// src/AdLoader.ts
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var SLOT_CATEGORY_HINTS = {
+  hero: "sports",
+  banner: "finance",
+  sidebar: "travel",
+  recommended: "food",
+  interstitial: "gaming",
+  footer: "technology"
+};
+var AdLoader = class {
+  constructor(client, debug = false) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.loading = /* @__PURE__ */ new Set();
+    this.client = client;
+    this.debug = debug;
+  }
+  isCacheValid(entry) {
+    return Date.now() - entry.timestamp < CACHE_TTL_MS;
+  }
+  getCategoryHint(slot) {
+    if (SLOT_CATEGORY_HINTS[slot]) return SLOT_CATEGORY_HINTS[slot];
+    const lowerSlot = slot.toLowerCase();
+    for (const [keyword, category] of Object.entries(SLOT_CATEGORY_HINTS)) {
+      if (lowerSlot.includes(keyword)) return category;
+    }
+    return void 0;
+  }
+  async load(slot, options) {
+    const cacheKey = `${slot}:${JSON.stringify(options ?? {})}`;
+    const cached = this.cache.get(cacheKey);
+    if (cached && this.isCacheValid(cached)) {
+      if (this.debug) {
+        console.log(`[Halo Ads] \u{1F4BE} Serving from cache \u2014 slot="${slot}"`);
+      }
+      return cached.ad;
+    }
+    if (this.loading.has(cacheKey)) {
+      if (this.debug) {
+        console.log(`[Halo Ads] \u23F3 Request in-flight for slot="${slot}", waiting...`);
+      }
+      return new Promise((resolve) => {
+        const interval = setInterval(() => {
+          const entry = this.cache.get(cacheKey);
+          if (entry) {
+            clearInterval(interval);
+            resolve(entry.ad);
+          }
+        }, 50);
+      });
+    }
+    this.loading.add(cacheKey);
+    if (this.debug) {
+      console.log(`[Halo Ads] \u{1F504} Loading slot="${slot}"`);
+    }
+    try {
+      const categoryHint = this.getCategoryHint(slot);
+      const ad = await this.client.fetchAd(slot, {
+        ...options,
+        targeting: categoryHint ? { category: categoryHint, ...options?.targeting } : options?.targeting
+      });
+      this.cache.set(cacheKey, { ad, timestamp: Date.now() });
+      return ad;
+    } finally {
+      this.loading.delete(cacheKey);
+    }
+  }
+  /** Clear cache for a slot (force refresh on next load) */
+  invalidate(slot) {
+    if (slot) {
+      for (const key of this.cache.keys()) {
+        if (key.startsWith(`${slot}:`)) {
+          this.cache.delete(key);
+        }
+      }
+    } else {
+      this.cache.clear();
+    }
+  }
+};
+
+// src/Analytics.ts
+var Analytics = class {
+  constructor(provider) {
+    this.config = null;
+    this.sessionId = "";
+    this.provider = provider ?? new ConsoleAnalyticsProvider();
+  }
+  configure(config, sessionId) {
+    this.config = config;
+    this.sessionId = sessionId;
+  }
+  track(name, payload) {
+    if (!this.config) {
+      console.warn("[Halo Ads] Analytics not configured. Call HaloAds.init() first.");
+      return;
+    }
+    const event = {
+      name,
+      payload,
+      publisherId: this.config.publisherId,
+      sessionId: this.sessionId,
+      timestamp: Date.now(),
+      url: typeof window !== "undefined" ? window.location.href : "",
+      userAgent: typeof navigator !== "undefined" ? navigator.userAgent : ""
+    };
+    this.provider.send(event).catch((err) => {
+      if (this.config?.debug) {
+        console.error("[Halo Ads] Failed to send analytics event:", err);
+      }
+    });
+  }
+};
+var ConsoleAnalyticsProvider = class {
+  async send(event) {
+    const icon = event.name === "impression" ? "\u{1F441}" : event.name === "click" ? "\u{1F5B1}" : event.name === "page_view" ? "\u{1F4C4}" : "\u{1F4CA}";
+    console.log(
+      `%c[Halo Ads] ${icon} ${event.name}`,
+      "color: #6366f1; font-weight: bold;",
+      {
+        publisherId: event.publisherId,
+        sessionId: event.sessionId,
+        timestamp: new Date(event.timestamp).toISOString(),
+        ...event.payload ?? {}
+      }
+    );
+  }
+};
+
+// src/EventTracker.ts
+var EventTracker = class {
+  constructor(analytics, profileStore, debug = false) {
+    this.trackedImpressions = /* @__PURE__ */ new Set();
+    this.analytics = analytics;
+    this.profileStore = profileStore;
+    this.debug = debug;
+  }
+  trackImpression(ad, slot) {
+    const key = `${ad.id}:${slot}`;
+    if (this.trackedImpressions.has(key)) {
+      return;
+    }
+    this.trackedImpressions.add(key);
+    this.profileStore.markAdSeen(ad.id);
+    this.profileStore.addInterest(ad.category);
+    if (this.debug) {
+      console.log(`[Halo Ads] \u{1F441} Impression tracked \u2014 ad=${ad.id} slot=${slot}`);
+    }
+    this.analytics.track("impression", {
+      adId: ad.id,
+      slot,
+      label: ad.title
+    });
+  }
+  trackClick(ad, slot) {
+    if (this.debug) {
+      console.log(`[Halo Ads] \u{1F5B1} Click tracked \u2014 ad=${ad.id} slot=${slot}`);
+    }
+    this.profileStore.addInterest(ad.category);
+    this.analytics.track("click", {
+      adId: ad.id,
+      slot,
+      label: ad.title,
+      url: ad.url
+    });
+  }
+  trackView(ad, slot) {
+    if (this.debug) {
+      console.log(`[Halo Ads] \u{1F52D} View tracked \u2014 ad=${ad.id} slot=${slot}`);
+    }
+    this.analytics.track("view", {
+      adId: ad.id,
+      slot
+    });
+  }
+  /** Set up IntersectionObserver to auto-track impressions */
+  observeElement(element, ad, slot) {
+    if (typeof IntersectionObserver === "undefined") {
+      this.trackImpression(ad, slot);
+      return () => {
+      };
+    }
+    const observer = new IntersectionObserver(
+      (entries) => {
+        entries.forEach((entry) => {
+          if (entry.isIntersecting && entry.intersectionRatio >= 0.5) {
+            this.trackImpression(ad, slot);
+            observer.unobserve(element);
+          }
+        });
+      },
+      { threshold: 0.5 }
+    );
+    observer.observe(element);
+    return () => observer.unobserve(element);
+  }
+};
+
+// src/mock/MockAdProvider.ts
+var MOCK_ADS = [
+  {
+    id: "ad_001",
+    title: "Ultra Boost Running Shoes",
+    description: "Engineered for peak performance. Lightweight foam technology with superior cushioning. Run faster, go further.",
+    image: "https://images.unsplash.com/photo-1542291026-7eec264c27ff?w=800&q=80",
+    url: "https://example.com/sports-shoes",
+    category: "sports",
+    ctaText: "Shop Now",
+    advertiser: "SpeedForce Athletics",
+    sponsoredLabel: "Sponsored",
+    theme: {
+      primaryColor: "#FF4500",
+      backgroundColor: "#1a1a2e",
+      ctaBackground: "#FF4500",
+      ctaTextColor: "#ffffff"
+    }
+  },
+  {
+    id: "ad_002",
+    title: "Crypto Trading \u2014 Get $50 Bonus",
+    description: "Trade Bitcoin, Ethereum & 200+ altcoins with zero fees. New users get $50 trading credit instantly.",
+    image: "https://images.unsplash.com/photo-1611974789855-9c2a0a7236a3?w=800&q=80",
+    url: "https://example.com/crypto-trading",
+    category: "finance",
+    ctaText: "Claim Bonus",
+    advertiser: "CryptoVault Exchange",
+    sponsoredLabel: "Promoted",
+    theme: {
+      primaryColor: "#F7931A",
+      backgroundColor: "#0d1117",
+      ctaBackground: "#F7931A",
+      ctaTextColor: "#000000"
+    }
+  },
+  {
+    id: "ad_003",
+    title: "Win Big \u2014 Casino Welcome Offer",
+    description: "200% match bonus up to $500 on your first deposit. 50 free spins on top slots. 18+ only. T&Cs apply.",
+    image: "https://images.unsplash.com/photo-1596838132731-3301c3fd4317?w=800&q=80",
+    url: "https://example.com/casino",
+    category: "gaming",
+    ctaText: "Play Now",
+    advertiser: "LuxeRoyal Casino",
+    sponsoredLabel: "Ad",
+    theme: {
+      primaryColor: "#FFD700",
+      backgroundColor: "#1a0a00",
+      ctaBackground: "#FFD700",
+      ctaTextColor: "#000000"
+    }
+  },
+  {
+    id: "ad_004",
+    title: "Bali for $399 \u2014 Limited Time",
+    description: "All-inclusive 7-night Bali escape. Flight + hotel + breakfast included. Only 12 seats remaining.",
+    image: "https://images.unsplash.com/photo-1537996194471-e657df975ab4?w=800&q=80",
+    url: "https://example.com/travel",
+    category: "travel",
+    ctaText: "Book Flight",
+    advertiser: "SkyWander Travel",
+    sponsoredLabel: "Sponsored",
+    theme: {
+      primaryColor: "#00BCD4",
+      backgroundColor: "#001f3f",
+      ctaBackground: "#00BCD4",
+      ctaTextColor: "#ffffff"
+    }
+  },
+  {
+    id: "ad_005",
+    title: "Free Delivery on Your First Order",
+    description: "From sushi to burgers \u2014 500+ restaurants near you. Order in 30 minutes or it's free. Use code HALO.",
+    image: "https://images.unsplash.com/photo-1565299624946-b28f40a0ae38?w=800&q=80",
+    url: "https://example.com/food-delivery",
+    category: "food",
+    ctaText: "Order Now",
+    advertiser: "QuickBite",
+    sponsoredLabel: "Ad",
+    theme: {
+      primaryColor: "#FF6B35",
+      backgroundColor: "#1a0500",
+      ctaBackground: "#FF6B35",
+      ctaTextColor: "#ffffff"
+    }
+  }
+];
+var MockAdProvider = class {
+  constructor() {
+    this.ads = MOCK_ADS;
+  }
+  /**
+   * Simulate network latency for a realistic dev experience.
+   */
+  delay(ms = 80) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Pick an ad for a given request. In a real implementation this
+   * would call POST /v1/decide with targeting parameters.
+   */
+  async fetchAd(request) {
+    await this.delay();
+    const requestId = `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const slotHash = request.slot.split("").reduce((acc, c) => acc + c.charCodeAt(0), 0);
+    const ad = this.ads[slotHash % this.ads.length];
+    return {
+      ad,
+      slot: request.slot,
+      requestId,
+      fill: true,
+      timestamp: Date.now()
+    };
+  }
+  async fetchAds(requests) {
+    return Promise.all(requests.map((r) => this.fetchAd(r)));
+  }
+  /** Exposed for testing / preview */
+  getAllAds() {
+    return [...this.ads];
+  }
+};
+
+// src/Recommendation.ts
+var Recommendation = class {
+  /**
+   * Rank ads by user interest score.
+   * Categories matching user interests are scored higher.
+   * Future: embed-based cosine similarity against interest vectors.
+   */
+  rankAds(ads, profile) {
+    if (profile.interests.length === 0) return [...ads];
+    const interestSet = new Set(profile.interests);
+    return [...ads].sort((a, b) => {
+      const scoreA = interestSet.has(a.category) ? 2 : 0;
+      const scoreB = interestSet.has(b.category) ? 2 : 0;
+      const seenA = profile.seenAdIds.includes(a.id) ? -1 : 0;
+      const seenB = profile.seenAdIds.includes(b.id) ? -1 : 0;
+      return scoreB + seenB - (scoreA + seenA);
+    });
+  }
+  /**
+   * Get recommended ads for a user.
+   * Returns ranked list excluding recently seen (if possible).
+   */
+  getRecommended(profile, limit = 5) {
+    const ranked = this.rankAds(MOCK_ADS, profile);
+    const unseen = ranked.filter((ad) => !profile.seenAdIds.includes(ad.id));
+    if (unseen.length >= limit) return unseen.slice(0, limit);
+    return ranked.slice(0, limit);
+  }
+};
+
+// src/renderer/DOMRenderer.ts
+var HALO_ATTR = "data-halo-ad";
+var HALO_ROOT_ID = "__halo_root__";
+var AUTO_DISMISS_MS = 9e3;
+var MAX_STACK = 3;
+var stylesInjected = false;
+function injectStyles() {
+  if (stylesInjected || typeof document === "undefined") return;
+  stylesInjected = true;
+  const style = document.createElement("style");
+  style.id = "__halo_styles__";
+  style.textContent = `
+    #__halo_root__ {
+      position: fixed;
+      top: 76px;
+      right: 20px;
+      z-index: 2147483647;
+      display: flex;
+      flex-direction: column;
+      gap: 12px;
+      align-items: flex-end;
+      pointer-events: none;
+      font-family: -apple-system, BlinkMacSystemFont, 'Inter', 'Segoe UI', sans-serif;
+    }
+
+    .halo-popup {
+      width: 330px;
+      background: rgba(10, 10, 22, 0.94);
+      backdrop-filter: blur(28px) saturate(160%);
+      -webkit-backdrop-filter: blur(28px) saturate(160%);
+      border: 1px solid rgba(255,255,255,0.1);
+      border-radius: 18px;
+      box-shadow:
+        0 8px 40px rgba(0,0,0,0.65),
+        0 0 0 1px rgba(255,255,255,0.04) inset;
+      overflow: hidden;
+      pointer-events: all;
+      transform: translateX(calc(100% + 28px));
+      opacity: 0;
+      transition:
+        transform 0.44s cubic-bezier(0.34, 1.28, 0.64, 1),
+        opacity 0.32s ease;
+      will-change: transform, opacity;
+    }
+
+    .halo-popup.halo-in {
+      transform: translateX(0);
+      opacity: 1;
+    }
+
+    .halo-popup.halo-out {
+      transform: translateX(calc(100% + 28px));
+      opacity: 0;
+      transition:
+        transform 0.28s cubic-bezier(0.55, 0, 1, 0.45),
+        opacity 0.22s ease;
+    }
+
+    .halo-popup__bar {
+      height: 3px;
+    }
+
+    .halo-popup__header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 9px 13px 5px;
+    }
+
+    .halo-popup__sponsored {
+      display: flex;
+      align-items: center;
+      gap: 5px;
+      font-size: 9px;
+      font-weight: 700;
+      letter-spacing: 1.1px;
+      text-transform: uppercase;
+      color: rgba(255,255,255,0.32);
+    }
+
+    .halo-popup__dot {
+      width: 5px;
+      height: 5px;
+      border-radius: 50%;
+      animation: halo-blink 2s infinite;
+    }
+
+    @keyframes halo-blink {
+      0%, 100% { opacity: 1; }
+      50% { opacity: 0.3; }
+    }
+
+    .halo-popup__close {
+      width: 22px;
+      height: 22px;
+      border-radius: 50%;
+      background: rgba(255,255,255,0.07);
+      border: 1px solid rgba(255,255,255,0.1);
+      color: rgba(255,255,255,0.4);
+      font-size: 11px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      cursor: pointer;
+      transition: all 0.15s;
+      padding: 0;
+      font-family: inherit;
+      line-height: 1;
+    }
+
+    .halo-popup__close:hover {
+      background: rgba(255,255,255,0.14);
+      color: rgba(255,255,255,0.85);
+    }
+
+    .halo-popup__image {
+      width: 100%;
+      height: 144px;
+      object-fit: cover;
+      display: block;
+      transition: transform 0.4s ease;
+    }
+
+    .halo-popup__image:hover { transform: scale(1.03); }
+
+    .halo-popup__img-fallback {
+      width: 100%;
+      height: 144px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      font-size: 36px;
+      background: linear-gradient(135deg, #1a1a3e 0%, #0d0d22 100%);
+    }
+
+    .halo-popup__body {
+      padding: 13px 15px 4px;
+    }
+
+    .halo-popup__advertiser {
+      font-size: 10px;
+      font-weight: 700;
+      letter-spacing: 0.5px;
+      text-transform: uppercase;
+      margin-bottom: 4px;
+    }
+
+    .halo-popup__title {
+      font-size: 14px;
+      font-weight: 700;
+      color: #f1f5f9;
+      line-height: 1.35;
+      letter-spacing: -0.2px;
+      margin-bottom: 5px;
+    }
+
+    .halo-popup__desc {
+      font-size: 12px;
+      color: rgba(226,232,240,0.48);
+      line-height: 1.55;
+      display: -webkit-box;
+      -webkit-line-clamp: 2;
+      -webkit-box-orient: vertical;
+      overflow: hidden;
+    }
+
+    .halo-popup__footer {
+      padding: 11px 15px 14px;
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 10px;
+    }
+
+    .halo-popup__cta {
+      flex: 1;
+      padding: 9px 14px;
+      border-radius: 10px;
+      border: none;
+      font-size: 12px;
+      font-weight: 700;
+      letter-spacing: 0.2px;
+      cursor: pointer;
+      font-family: inherit;
+      text-decoration: none;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 4px;
+      transition: filter 0.15s, transform 0.15s;
+      box-shadow: 0 3px 12px rgba(0,0,0,0.3);
+    }
+
+    .halo-popup__cta:hover {
+      filter: brightness(1.12);
+      transform: translateY(-1px);
+    }
+
+    .halo-popup__cta:active { transform: translateY(0); }
+
+    .halo-popup__byline {
+      font-size: 9px;
+      color: rgba(255,255,255,0.18);
+      letter-spacing: 0.1px;
+      white-space: nowrap;
+    }
+
+    .halo-popup__progress {
+      height: 2px;
+      background: rgba(255,255,255,0.05);
+      overflow: hidden;
+    }
+
+    .halo-popup__progress-fill {
+      height: 100%;
+      background: rgba(255,255,255,0.16);
+      transform-origin: left;
+      will-change: transform;
+    }
+  `;
+  document.head.appendChild(style);
+}
+function getOrCreateRoot() {
+  let root = document.getElementById(HALO_ROOT_ID);
+  if (!root) {
+    root = document.createElement("div");
+    root.id = HALO_ROOT_ID;
+    document.body.appendChild(root);
+  }
+  return root;
+}
+function categoryEmoji(category) {
+  const map = {
+    sports: "\u{1F45F}",
+    finance: "\u{1F4B0}",
+    travel: "\u2708\uFE0F",
+    food: "\u{1F354}",
+    gaming: "\u{1F3AE}",
+    technology: "\u{1F4BB}",
+    fashion: "\u{1F457}",
+    health: "\u{1F48A}",
+    entertainment: "\u{1F3AC}"
+  };
+  return map[category] ?? "\u{1F4E2}";
+}
+var DOMRenderer = class {
+  constructor(tracker, debug = false) {
+    this.activeCount = 0;
+    this.timers = /* @__PURE__ */ new Map();
+    this.tracker = tracker;
+    this.debug = debug;
+  }
+  resolveContainer(container) {
+    if (typeof container === "string") {
+      return document.querySelector(container);
+    }
+    return container;
+  }
+  closePopup(popup, slotId) {
+    const timer = this.timers.get(slotId);
+    if (timer) {
+      clearTimeout(timer);
+      this.timers.delete(slotId);
+    }
+    popup.classList.remove("halo-in");
+    popup.classList.add("halo-out");
+    this.activeCount = Math.max(0, this.activeCount - 1);
+    setTimeout(() => popup.remove(), 320);
+  }
+  async render(ad, options) {
+    if (typeof document === "undefined") return;
+    if (this.activeCount >= MAX_STACK) {
+      if (this.debug) console.log("[Halo Ads] Max popup stack reached, queuing...");
+      await new Promise((r) => setTimeout(r, 2e3));
+    }
+    injectStyles();
+    const root = getOrCreateRoot();
+    const slotId = options.slot + "_" + Date.now();
+    const accent = ad.theme?.primaryColor ?? "#6366f1";
+    const ctaBg = ad.theme?.ctaBackground ?? accent;
+    const ctaFg = ad.theme?.ctaTextColor ?? "#ffffff";
+    const popup = document.createElement("div");
+    popup.className = "halo-popup";
+    popup.setAttribute(HALO_ATTR, ad.id);
+    popup.setAttribute("data-slot", options.slot);
+    popup.setAttribute("role", "complementary");
+    popup.setAttribute("aria-label", `Sponsored: ${ad.title}`);
+    popup.innerHTML = `
+      <div class="halo-popup__bar" style="background:${accent};box-shadow:0 0 14px ${accent}55;"></div>
+
+      <div class="halo-popup__header">
+        <div class="halo-popup__sponsored">
+          <div class="halo-popup__dot" style="background:${accent};box-shadow:0 0 5px ${accent};"></div>
+          Sponsored
+        </div>
+        <button class="halo-popup__close" aria-label="Close ad">\u2715</button>
+      </div>
+
+      <img
+        class="halo-popup__image"
+        src="${ad.image}"
+        alt="${ad.title}"
+        loading="lazy"
+      />
+      <div class="halo-popup__img-fallback" style="display:none;">${categoryEmoji(ad.category)}</div>
+
+      <div class="halo-popup__body">
+        <div class="halo-popup__advertiser" style="color:${accent};">${ad.advertiser ?? ""}</div>
+        <div class="halo-popup__title">${ad.title}</div>
+        <div class="halo-popup__desc">${ad.description}</div>
+      </div>
+
+      <div class="halo-popup__footer">
+        <a
+          class="halo-popup__cta"
+          href="${ad.url}"
+          target="_blank"
+          rel="noopener noreferrer"
+          data-halo-cta="${ad.id}"
+          style="background:${ctaBg};color:${ctaFg};"
+        >${ad.ctaText} \u2192</a>
+        <span class="halo-popup__byline">Ad \xB7 haloads.com</span>
+      </div>
+
+      <div class="halo-popup__progress">
+        <div class="halo-popup__progress-fill" id="halo-prog-${slotId}"></div>
+      </div>
+    `;
+    root.appendChild(popup);
+    this.activeCount++;
+    const img = popup.querySelector(".halo-popup__image");
+    const fallback = popup.querySelector(".halo-popup__img-fallback");
+    img.addEventListener("error", () => {
+      img.style.display = "none";
+      fallback.style.display = "flex";
+    });
+    const closeBtn = popup.querySelector(".halo-popup__close");
+    closeBtn.addEventListener("click", () => this.closePopup(popup, slotId));
+    const cta = popup.querySelector(`[data-halo-cta="${ad.id}"]`);
+    cta?.addEventListener("click", (e) => {
+      e.stopPropagation();
+      this.tracker.trackClick(ad, options.slot);
+      options.onClick?.(ad);
+    });
+    requestAnimationFrame(() => requestAnimationFrame(() => popup.classList.add("halo-in")));
+    const prog = document.getElementById(`halo-prog-${slotId}`);
+    if (prog) {
+      prog.style.transition = `transform ${AUTO_DISMISS_MS}ms linear`;
+      requestAnimationFrame(() => {
+        prog.style.transform = "scaleX(0)";
+      });
+    }
+    const timer = setTimeout(() => this.closePopup(popup, slotId), AUTO_DISMISS_MS);
+    this.timers.set(slotId, timer);
+    this.tracker.observeElement(popup, ad, options.slot);
+    options.onImpression?.(ad);
+    if (this.debug) {
+      console.log(`[Halo Ads] \u{1F3AF} Popup shown \u2014 slot="${options.slot}" ad="${ad.id}"`);
+    }
+  }
+  clear(container) {
+    const el = this.resolveContainer(container);
+    el?.querySelectorAll(`[${HALO_ATTR}]`).forEach((node) => node.remove());
+  }
+};
+
+// src/storage/ProfileStore.ts
+var STORAGE_KEY = "__halo_profile__";
+var SESSION_DURATION_MS = 30 * 60 * 1e3;
+function generateId(prefix) {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function detectDevice() {
+  if (typeof navigator === "undefined") return "unknown";
+  const ua = navigator.userAgent.toLowerCase();
+  if (/mobile|android|iphone|ipad/.test(ua)) {
+    return /ipad|tablet/.test(ua) ? "tablet" : "mobile";
+  }
+  return "desktop";
+}
+function detectLanguage() {
+  if (typeof navigator === "undefined") return "en";
+  return navigator.language?.split("-")[0] ?? "en";
+}
+function createDefaultProfile() {
+  return {
+    interests: [],
+    language: detectLanguage(),
+    country: "",
+    device: detectDevice(),
+    sessionId: generateId("ses"),
+    firstSeen: Date.now(),
+    lastSeen: Date.now(),
+    seenAdIds: []
+  };
+}
+function isStorageAvailable() {
+  try {
+    const test = "__halo_test__";
+    localStorage.setItem(test, "1");
+    localStorage.removeItem(test);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var ProfileStore = class {
+  constructor() {
+    this.storageAvailable = isStorageAvailable();
+    this.profile = this.load();
+  }
+  load() {
+    if (!this.storageAvailable) {
+      return createDefaultProfile();
+    }
+    try {
+      const raw = localStorage.getItem(STORAGE_KEY);
+      if (!raw) return createDefaultProfile();
+      const stored = JSON.parse(raw);
+      const sessionExpired = Date.now() - stored.lastSeen > SESSION_DURATION_MS;
+      if (sessionExpired) {
+        stored.sessionId = generateId("ses");
+        stored.seenAdIds = [];
+      }
+      stored.lastSeen = Date.now();
+      stored.device = detectDevice();
+      stored.language = detectLanguage();
+      return stored;
+    } catch {
+      return createDefaultProfile();
+    }
+  }
+  save() {
+    if (!this.storageAvailable) return;
+    try {
+      localStorage.setItem(STORAGE_KEY, JSON.stringify(this.profile));
+    } catch {
+    }
+  }
+  get() {
+    return { ...this.profile };
+  }
+  update(partial) {
+    this.profile = {
+      ...this.profile,
+      ...partial,
+      lastSeen: Date.now()
+    };
+    this.save();
+  }
+  /** Add an ad ID to the seen list (for frequency capping) */
+  markAdSeen(adId) {
+    if (!this.profile.seenAdIds.includes(adId)) {
+      this.profile.seenAdIds = [...this.profile.seenAdIds, adId];
+      this.save();
+    }
+  }
+  /** Add an interest if not already present */
+  addInterest(interest) {
+    if (!this.profile.interests.includes(interest)) {
+      this.profile.interests = [...this.profile.interests, interest];
+      this.save();
+    }
+  }
+  clear() {
+    this.profile = createDefaultProfile();
+    if (this.storageAvailable) {
+      localStorage.removeItem(STORAGE_KEY);
+    }
+  }
+};
+
+// src/HaloAds.ts
+var HaloAdsSDK = class {
+  constructor() {
+    this.config = null;
+    this.profileStore = null;
+    this.analytics = null;
+    this.tracker = null;
+    this.client = null;
+    this.loader = null;
+    this.renderer = null;
+    this.recommendation = null;
+  }
+  // ── Public API ───────────────────────────────
+  /**
+   * Initialize the Halo Ads SDK.
+   * Must be called before any other methods.
+   *
+   * @example
+   * HaloAds.init({
+   *   publisherId: "pub_001",
+   *   apiKey: "pk_test_...",
+   *   debug: true
+   * });
+   */
+  init(config) {
+    if (this.config) {
+      if (config.debug) {
+        console.warn("[Halo Ads] Already initialized. Call destroy() first to re-initialize.");
+      }
+      return;
+    }
+    this.config = {
+      environment: "development",
+      debug: false,
+      ...config
+    };
+    const debug = this.config.debug ?? false;
+    if (debug) {
+      console.log(
+        "%c[Halo Ads] \u{1F680} Initialized",
+        "color: #6366f1; font-weight: bold; font-size: 13px;",
+        {
+          publisherId: config.publisherId,
+          environment: this.config.environment,
+          version: "0.1.0"
+        }
+      );
+    }
+    this.profileStore = new ProfileStore();
+    this.analytics = new Analytics();
+    this.analytics.configure(this.config, this.profileStore.get().sessionId);
+    this.tracker = new EventTracker(this.analytics, this.profileStore, debug);
+    const adProvider = new MockAdProvider();
+    this.client = new AdClient(adProvider, config.publisherId, debug);
+    this.loader = new AdLoader(this.client, debug);
+    this.renderer = new DOMRenderer(this.tracker, debug);
+    this.recommendation = new Recommendation();
+    this.analytics.track("page_view");
+  }
+  /**
+   * Track an analytics event.
+   *
+   * @example
+   * HaloAds.track("page_view")
+   * HaloAds.track("click", { adId: "ad_001" })
+   * HaloAds.track("purchase", { value: 49.99 })
+   */
+  track(name, payload) {
+    this.assertInitialized("track");
+    this.analytics.track(name, payload);
+  }
+  /**
+   * Fetch an ad for a slot.
+   *
+   * @example
+   * const ad = await HaloAds.getAd({ slot: "hero" })
+   */
+  async getAd(request) {
+    this.assertInitialized("getAd");
+    return this.loader.load(request.slot, request);
+  }
+  /**
+   * Render an ad into a DOM container.
+   * Works like Google Adsense — just point at a container.
+   *
+   * @example
+   * HaloAds.render({ container: "#banner", slot: "hero" })
+   */
+  async render(options) {
+    this.assertInitialized("render");
+    if (this.config?.debug) {
+      console.log(`[Halo Ads] \u{1F3A8} Rendering slot="${options.slot}"...`);
+    }
+    const ad = await this.loader.load(options.slot, {
+      format: options.format
+    });
+    if (!ad) {
+      if (this.config?.debug) {
+        console.log(`[Halo Ads] \u26AA No ad to render for slot="${options.slot}"`);
+      }
+      return;
+    }
+    await this.renderer.render(ad, options);
+  }
+  /**
+   * Get the current user profile.
+   */
+  getProfile() {
+    this.assertInitialized("getProfile");
+    return this.profileStore.get();
+  }
+  /**
+   * Get recommended ads based on user profile.
+   */
+  getRecommended(limit = 5) {
+    this.assertInitialized("getRecommended");
+    return this.recommendation.getRecommended(this.profileStore.get(), limit);
+  }
+  /**
+   * Whether the SDK has been initialized.
+   */
+  isInitialized() {
+    return this.config !== null;
+  }
+  /**
+   * Destroy the SDK instance (useful for testing / cleanup).
+   */
+  destroy() {
+    this.config = null;
+    this.profileStore = null;
+    this.analytics = null;
+    this.tracker = null;
+    this.client = null;
+    this.loader = null;
+    this.renderer = null;
+    this.recommendation = null;
+  }
+  // ── Internal helpers ─────────────────────────
+  /** @internal */
+  _getTracker() {
+    this.assertInitialized("_getTracker");
+    return this.tracker;
+  }
+  /** @internal */
+  _getProfileStore() {
+    this.assertInitialized("_getProfileStore");
+    return this.profileStore;
+  }
+  assertInitialized(method) {
+    if (!this.config) {
+      throw new Error(
+        `[Halo Ads] SDK not initialized. Call HaloAds.init() before HaloAds.${method}().`
+      );
+    }
+  }
+};
+var HaloAds = new HaloAdsSDK();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AdClient,
+  AdLoader,
+  Analytics,
+  ConsoleAnalyticsProvider,
+  DOMRenderer,
+  EventTracker,
+  HaloAds,
+  MOCK_ADS,
+  MockAdProvider,
+  ProfileStore,
+  Recommendation
+});