@active-reach/web-sdk 1.43.1 → 1.43.3

package/dist/analytics-C-Go3Pm5.mjs

@@ -0,0 +1,3509 @@
+const DEFAULT_CONFIG = {
+  workspace_id: null,
+  batch_size: 10,
+  batch_interval: 1e3,
+  capture_utm: true,
+  capture_referrer: true,
+  auto_page_view: false,
+  session_timeout: 30,
+  debug: false,
+  respect_dnt: true,
+  cross_domain_tracking: false,
+  secure_cookie: true,
+  enable_offline_mode: true,
+  max_offline_events: 100,
+  retry_failed_requests: true,
+  max_retries: 3,
+  retry_backoff_multiplier: 2,
+  request_timeout: 5e3,
+  rate_limit_burst: 100,
+  rate_limit_per_second: 20,
+  auto_region_detection: true,
+  wait_for_consent: false,
+  enable_consent_mode: false,
+  integrate_onetrust: false,
+  integrate_cookiebot: false,
+  integrate_google_consent_mode: false,
+  default_consent: {
+    analytics: false,
+    marketing: false,
+    functional: true
+  },
+  initialized: false,
+  api_host: null,
+  cell_endpoints: [],
+  preferred_region: null,
+  cookie_domain: null,
+  plugins: [],
+  active_cell: null
+};
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function generateSessionId() {
+  return `sess_${Date.now()}_${generateUUID().slice(0, 8)}`;
+}
+function generateMessageId() {
+  return `msg_${Date.now()}_${generateUUID().slice(0, 8)}`;
+}
+class Logger {
+  constructor() {
+    this.enabled = false;
+    this.prefix = "[Active Reach SDK]";
+  }
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  debug(message, ...args) {
+    if (!this.enabled) return;
+    console.debug(`${this.prefix} ${message}`, ...args);
+  }
+  info(message, ...args) {
+    if (!this.enabled) return;
+    console.info(`${this.prefix} ${message}`, ...args);
+  }
+  warn(message, ...args) {
+    console.warn(`${this.prefix} ${message}`, ...args);
+  }
+  error(message, ...args) {
+    console.error(`${this.prefix} ${message}`, ...args);
+  }
+}
+const logger = new Logger();
+class Identity {
+  constructor(storage) {
+    this.userId = null;
+    this.traits = {};
+    this.storage = storage;
+    this.anonymousId = this.getOrCreateAnonymousId();
+    this.loadUserIdentity();
+  }
+  getOrCreateAnonymousId() {
+    let id = this.storage.get("anon_id");
+    if (!id) {
+      id = generateUUID();
+      this.storage.set("anon_id", id, 365);
+      logger.debug("Created new anonymous ID:", id);
+    } else {
+      logger.debug("Loaded existing anonymous ID:", id);
+    }
+    return id;
+  }
+  loadUserIdentity() {
+    const storedUserId = this.storage.get("user_id");
+    const storedTraits = this.storage.get("user_traits");
+    if (storedUserId) {
+      this.userId = storedUserId;
+      logger.debug("Loaded user ID:", storedUserId);
+    }
+    if (storedTraits) {
+      try {
+        this.traits = JSON.parse(storedTraits);
+        logger.debug("Loaded user traits:", this.traits);
+      } catch (error) {
+        logger.warn("Failed to parse stored traits:", error);
+        this.traits = {};
+      }
+    }
+  }
+  getAnonymousId() {
+    return this.anonymousId;
+  }
+  setUserId(userId, traits) {
+    this.userId = userId;
+    this.storage.set("user_id", userId, 365);
+    logger.info("User identified:", userId);
+    if (traits) {
+      this.setTraits(traits);
+    }
+  }
+  getUserId() {
+    return this.userId;
+  }
+  setTraits(traits) {
+    this.traits = { ...this.traits, ...traits };
+    this.storage.set("user_traits", JSON.stringify(this.traits), 365);
+    logger.debug("User traits updated:", this.traits);
+  }
+  getTraits() {
+    return { ...this.traits };
+  }
+  reset() {
+    this.userId = null;
+    this.traits = {};
+    this.anonymousId = generateUUID();
+    this.storage.remove("user_id");
+    this.storage.remove("user_traits");
+    this.storage.set("anon_id", this.anonymousId, 365);
+    logger.info("Identity reset, new anonymous ID:", this.anonymousId);
+  }
+  alias(newUserId) {
+    const previousId = this.userId || this.anonymousId;
+    this.setUserId(newUserId);
+    logger.info("User aliased:", { previousId, newUserId });
+    return { previousId, newUserId };
+  }
+  getState() {
+    return {
+      anonymousId: this.anonymousId,
+      userId: this.userId,
+      traits: this.getTraits()
+    };
+  }
+}
+const LINK_ATTRIBUTION_DURABLE_DAYS = 30;
+class SessionManager {
+  constructor(storage, sessionTimeoutMinutes = 30) {
+    this.eventCount = 0;
+    this.checkInterval = null;
+    this.activityThrottle = 1e3;
+    this.lastActivityUpdate = 0;
+    this.adClickIDs = {};
+    this.linkAttribution = {};
+    this.storage = storage;
+    this.sessionTimeout = sessionTimeoutMinutes * 60 * 1e3;
+    this.lastActivityTime = Date.now();
+    this.sessionStartTime = Date.now();
+    const session = this.loadSession();
+    if (session) {
+      this.sessionId = session.sessionId;
+      this.sessionStartTime = session.startTime;
+      this.lastActivityTime = session.lastActivityTime;
+      this.eventCount = session.eventCount;
+      this.adClickIDs = session.adClickIDs || {};
+      this.landingPage = session.landingPage;
+      this.linkAttribution = session.linkAttribution || {};
+      logger.debug("Session loaded:", session);
+    } else {
+      this.sessionId = this.createNewSession();
+    }
+    this.startActivityTracking();
+    this.startExpiryCheck();
+  }
+  loadSession() {
+    const sessionData = this.storage.get("session");
+    if (!sessionData) {
+      return null;
+    }
+    try {
+      const session = JSON.parse(sessionData);
+      const elapsed = Date.now() - session.lastActivityTime;
+      if (elapsed < this.sessionTimeout) {
+        return session;
+      } else {
+        logger.debug("Session expired, creating new session");
+        this.storage.remove("session");
+        return null;
+      }
+    } catch (error) {
+      logger.warn("Failed to parse session data:", error);
+      this.storage.remove("session");
+      return null;
+    }
+  }
+  createNewSession() {
+    const newSessionId = generateSessionId();
+    this.sessionStartTime = Date.now();
+    this.lastActivityTime = Date.now();
+    this.eventCount = 0;
+    this.sessionId = newSessionId;
+    this.persistSession();
+    logger.info("New session created:", newSessionId);
+    return newSessionId;
+  }
+  persistSession() {
+    const sessionData = {
+      sessionId: this.sessionId,
+      startTime: this.sessionStartTime,
+      lastActivityTime: this.lastActivityTime,
+      eventCount: this.eventCount,
+      adClickIDs: this.adClickIDs,
+      landingPage: this.landingPage,
+      linkAttribution: this.linkAttribution
+    };
+    this.storage.set("session", JSON.stringify(sessionData));
+  }
+  startActivityTracking() {
+    const events = ["click", "scroll", "keypress", "mousemove", "touchstart"];
+    const activityHandler = () => this.onActivity();
+    events.forEach((event) => {
+      window.addEventListener(event, activityHandler, { passive: true });
+    });
+    window.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "visible") {
+        this.onActivity();
+      }
+    });
+  }
+  startExpiryCheck() {
+    this.checkInterval = window.setInterval(() => {
+      this.checkSessionExpiry();
+    }, 6e4);
+  }
+  onActivity() {
+    const now = Date.now();
+    const timeSinceLastUpdate = now - this.lastActivityUpdate;
+    if (timeSinceLastUpdate < this.activityThrottle) {
+      return;
+    }
+    this.lastActivityUpdate = now;
+    const timeSinceLastActivity = now - this.lastActivityTime;
+    if (timeSinceLastActivity > this.sessionTimeout) {
+      logger.info("Session expired due to inactivity, creating new session");
+      this.sessionId = this.createNewSession();
+    } else {
+      this.lastActivityTime = now;
+      this.persistSession();
+    }
+  }
+  checkSessionExpiry() {
+    const elapsed = Date.now() - this.lastActivityTime;
+    if (elapsed > this.sessionTimeout) {
+      logger.info("Session expired during check, creating new session");
+      this.sessionId = this.createNewSession();
+    }
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  incrementEventCount() {
+    this.eventCount++;
+    this.lastActivityTime = Date.now();
+    this.persistSession();
+  }
+  getSessionDuration() {
+    return Date.now() - this.sessionStartTime;
+  }
+  getEventCount() {
+    return this.eventCount;
+  }
+  getState() {
+    return {
+      sessionId: this.sessionId,
+      startTime: this.sessionStartTime,
+      lastActivityTime: this.lastActivityTime,
+      eventCount: this.eventCount,
+      adClickIDs: this.adClickIDs,
+      landingPage: this.landingPage,
+      linkAttribution: this.linkAttribution
+    };
+  }
+  setAdClickIDs(adClickIDs, landingPage) {
+    if (Object.keys(adClickIDs).length > 0) {
+      this.adClickIDs = { ...this.adClickIDs, ...adClickIDs };
+      if (landingPage) {
+        this.landingPage = landingPage;
+      }
+      this.persistSession();
+      try {
+        this.storage.set("ad_click_ids", JSON.stringify(this.adClickIDs), 365);
+        if (this.landingPage) {
+          this.storage.set("ad_landing_page", this.landingPage, 365);
+        }
+      } catch {
+      }
+      logger.info("Ad click IDs stored (session + durable):", this.adClickIDs);
+    }
+  }
+  getAdClickIDs() {
+    if (Object.keys(this.adClickIDs).length === 0) {
+      try {
+        const durable = this.storage.get("ad_click_ids");
+        if (durable) {
+          const parsed = JSON.parse(durable);
+          if (parsed && Object.keys(parsed).length > 0) {
+            this.adClickIDs = parsed;
+            if (!this.landingPage) {
+              this.landingPage = this.storage.get("ad_landing_page") || void 0;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return this.adClickIDs;
+  }
+  getLandingPage() {
+    return this.landingPage;
+  }
+  /**
+   * Record the landing's Aegis link attribution. LAST touch: a new `aegis_code`
+   * replaces the previous set whole — never merged, because the fields are the
+   * attributes of ONE link and a mix of two links describes neither.
+   * Session + durable (30d, the server's short-link attribution window) so a
+   * checkout in a later session can still name the send that brought them.
+   */
+  setLinkAttribution(attribution) {
+    if (!attribution.aegis_code) return;
+    this.linkAttribution = { ...attribution };
+    this.persistSession();
+    try {
+      this.storage.set(
+        "link_attribution",
+        JSON.stringify(this.linkAttribution),
+        LINK_ATTRIBUTION_DURABLE_DAYS
+      );
+    } catch {
+    }
+  }
+  getLinkAttribution() {
+    if (!this.linkAttribution.aegis_code) {
+      try {
+        const durable = this.storage.get("link_attribution");
+        if (durable) {
+          const parsed = JSON.parse(durable);
+          if (parsed && parsed.aegis_code) {
+            this.linkAttribution = parsed;
+          }
+        }
+      } catch {
+      }
+    }
+    return this.linkAttribution;
+  }
+  destroy() {
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = null;
+    }
+  }
+}
+const FBP_COOKIE = "_fbp";
+const FBC_COOKIE = "_fbc";
+const COOKIE_LIFETIME_DAYS = 90;
+function readCookie(name) {
+  if (typeof document === "undefined") return null;
+  try {
+    const target = `${name}=`;
+    const parts = document.cookie.split(";");
+    for (let i = 0; i < parts.length; i++) {
+      let c = parts[i];
+      while (c.charAt(0) === " ") c = c.substring(1);
+      if (c.indexOf(target) === 0) {
+        return decodeURIComponent(c.substring(target.length));
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function writeCookie(name, value, days) {
+  if (typeof document === "undefined" || typeof window === "undefined") return;
+  try {
+    const expiry = new Date(Date.now() + days * 24 * 60 * 60 * 1e3).toUTCString();
+    const domain = getRootDomain();
+    const isHttps = window.location.protocol === "https:";
+    let cookieStr = `${name}=${encodeURIComponent(value)};expires=${expiry};path=/;SameSite=Lax`;
+    if (isHttps) cookieStr += ";Secure";
+    if (domain) cookieStr += `;domain=${domain}`;
+    document.cookie = cookieStr;
+  } catch {
+  }
+}
+function getRootDomain() {
+  if (typeof window === "undefined") return null;
+  const host = window.location.hostname;
+  if (!host || host === "localhost") return null;
+  if (/^\d+\.\d+\.\d+\.\d+$/.test(host)) return null;
+  const parts = host.split(".");
+  if (parts.length < 2) return null;
+  return "." + parts.slice(-2).join(".");
+}
+function subdomainIndex() {
+  if (typeof window === "undefined") return 1;
+  const host = window.location.hostname;
+  if (!host || host === "localhost" || /^\d+\.\d+\.\d+\.\d+$/.test(host)) return 1;
+  const parts = host.split(".");
+  return Math.max(1, parts.length - 1);
+}
+function randomToken() {
+  const n = Math.floor(Math.random() * 1e10);
+  return n.toString().padStart(10, "0");
+}
+function ensureFbp() {
+  const existing = readCookie(FBP_COOKIE);
+  if (existing) return existing;
+  const fbp = `fb.${subdomainIndex()}.${Date.now()}.${randomToken()}`;
+  writeCookie(FBP_COOKIE, fbp, COOKIE_LIFETIME_DAYS);
+  return fbp;
+}
+function ensureFbc() {
+  const existing = readCookie(FBC_COOKIE);
+  if (existing) return existing;
+  const fbclid = readFbclidFromUrl();
+  if (!fbclid) return null;
+  const fbc = `fb.${subdomainIndex()}.${Date.now()}.${fbclid}`;
+  writeCookie(FBC_COOKIE, fbc, COOKIE_LIFETIME_DAYS);
+  return fbc;
+}
+function readFbclidFromUrl() {
+  if (typeof window === "undefined") return null;
+  try {
+    return new URLSearchParams(window.location.search).get("fbclid");
+  } catch {
+    return null;
+  }
+}
+function captureMetaCookies() {
+  return {
+    fbp: ensureFbp(),
+    fbc: ensureFbc(),
+    fbclid: readFbclidFromUrl()
+  };
+}
+function redactMetaCookies(event) {
+  const props = event == null ? void 0 : event.properties;
+  if (!props || props.fbc === void 0 && props.fbp === void 0) return event;
+  const masked = { ...props };
+  if (masked.fbc !== void 0) masked.fbc = "[redacted]";
+  if (masked.fbp !== void 0) masked.fbp = "[redacted]";
+  return { ...event, properties: masked };
+}
+class EventQueue {
+  constructor(config, transport, storage) {
+    this.buffer = [];
+    this.flushInterval = null;
+    this.isFlushing = false;
+    this.offlineQueue = [];
+    this.isOnline = navigator.onLine;
+    this.config = config;
+    this.transport = transport;
+    this.storage = storage;
+    if (config.enableOfflineMode) {
+      this.loadOfflineQueue();
+      this.setupOnlineListener();
+    }
+    this.startFlushTimer();
+    this.setupUnloadHandlers();
+  }
+  loadOfflineQueue() {
+    const offlineData = this.storage.get("offline_queue");
+    if (!offlineData) {
+      return;
+    }
+    try {
+      const events = JSON.parse(offlineData);
+      if (Array.isArray(events) && events.length > 0) {
+        this.offlineQueue = events.slice(0, this.config.maxOfflineEvents);
+        logger.info(`Loaded ${this.offlineQueue.length} offline events`);
+        if (this.isOnline) {
+          this.flushOfflineQueue();
+        }
+      }
+    } catch (error) {
+      logger.warn("Failed to load offline queue:", error);
+      this.storage.remove("offline_queue");
+    }
+  }
+  saveOfflineQueue() {
+    if (this.offlineQueue.length === 0) {
+      this.storage.remove("offline_queue");
+      return;
+    }
+    try {
+      const data = JSON.stringify(this.offlineQueue);
+      this.storage.set("offline_queue", data);
+      logger.debug(`Saved ${this.offlineQueue.length} events to offline queue`);
+    } catch (error) {
+      logger.warn("Failed to save offline queue:", error);
+    }
+  }
+  setupOnlineListener() {
+    window.addEventListener("online", () => {
+      logger.info("Connection restored");
+      this.isOnline = true;
+      this.flushOfflineQueue();
+      this.flush();
+    });
+    window.addEventListener("offline", () => {
+      logger.warn("Connection lost, entering offline mode");
+      this.isOnline = false;
+    });
+  }
+  async flushOfflineQueue() {
+    if (this.offlineQueue.length === 0) {
+      return;
+    }
+    logger.info(`Flushing ${this.offlineQueue.length} offline events`);
+    const events = [...this.offlineQueue];
+    this.offlineQueue = [];
+    this.storage.remove("offline_queue");
+    const result = await this.transport.send(events);
+    if (!result.success) {
+      logger.warn("Failed to send offline events, re-queueing");
+      this.offlineQueue = [...events, ...this.offlineQueue].slice(
+        0,
+        this.config.maxOfflineEvents
+      );
+      this.saveOfflineQueue();
+    } else {
+      logger.info("Offline events sent successfully");
+    }
+  }
+  push(event) {
+    if (!this.isOnline && this.config.enableOfflineMode) {
+      this.addToOfflineQueue(event);
+      return;
+    }
+    this.buffer.push(event);
+    logger.debug("Event queued:", event.type, redactMetaCookies(event));
+    if (this.buffer.length >= this.config.batchSize) {
+      this.flush();
+    }
+  }
+  addToOfflineQueue(event) {
+    if (this.offlineQueue.length >= this.config.maxOfflineEvents) {
+      logger.warn("Offline queue full, dropping oldest event");
+      this.offlineQueue.shift();
+    }
+    this.offlineQueue.push(event);
+    this.saveOfflineQueue();
+    logger.debug("Event added to offline queue");
+  }
+  async flush() {
+    if (this.isFlushing) {
+      logger.debug("Flush already in progress, skipping");
+      return;
+    }
+    if (this.buffer.length === 0) {
+      return;
+    }
+    this.isFlushing = true;
+    const events = [...this.buffer];
+    this.buffer = [];
+    logger.info(`Flushing ${events.length} events`);
+    try {
+      const result = await this.transport.send(events);
+      if (!result.success) {
+        logger.error("Failed to send events:", result.error);
+        if (this.config.enableOfflineMode) {
+          this.offlineQueue = [...this.offlineQueue, ...events].slice(
+            0,
+            this.config.maxOfflineEvents
+          );
+          this.saveOfflineQueue();
+          logger.info("Events saved to offline queue");
+        } else {
+          this.buffer.unshift(...events);
+          logger.warn("Events re-queued for retry");
+        }
+      } else {
+        logger.info("Events sent successfully");
+      }
+    } catch (error) {
+      logger.error("Flush error:", error);
+      if (this.config.enableOfflineMode) {
+        this.offlineQueue = [...this.offlineQueue, ...events].slice(
+          0,
+          this.config.maxOfflineEvents
+        );
+        this.saveOfflineQueue();
+      }
+    } finally {
+      this.isFlushing = false;
+    }
+  }
+  startFlushTimer() {
+    if (this.flushInterval) {
+      clearInterval(this.flushInterval);
+    }
+    this.flushInterval = window.setInterval(() => {
+      this.flush();
+    }, this.config.batchInterval);
+    logger.debug(
+      `Flush timer started with interval: ${this.config.batchInterval}ms`
+    );
+  }
+  setupUnloadHandlers() {
+    const flushBeforeUnload = () => {
+      if (this.buffer.length > 0 || this.offlineQueue.length > 0) {
+        this.persistBufferToOfflineQueue();
+        this.flush();
+      }
+    };
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden") {
+        flushBeforeUnload();
+      }
+    });
+    window.addEventListener("beforeunload", flushBeforeUnload);
+    window.addEventListener("pagehide", flushBeforeUnload);
+  }
+  persistBufferToOfflineQueue() {
+    if (this.buffer.length === 0) {
+      return;
+    }
+    if (this.config.enableOfflineMode) {
+      this.offlineQueue = [...this.offlineQueue, ...this.buffer].slice(
+        0,
+        this.config.maxOfflineEvents
+      );
+      this.saveOfflineQueue();
+      logger.debug("Buffer persisted to offline queue before unload");
+    }
+  }
+  getQueueSize() {
+    return this.buffer.length;
+  }
+  getOfflineQueueSize() {
+    return this.offlineQueue.length;
+  }
+  clear() {
+    this.buffer = [];
+    this.offlineQueue = [];
+    this.storage.remove("offline_queue");
+    logger.info("Queue cleared");
+  }
+  destroy() {
+    if (this.flushInterval) {
+      clearInterval(this.flushInterval);
+      this.flushInterval = null;
+    }
+    this.flush();
+  }
+}
+class Transport {
+  constructor(config, storage) {
+    this.activeCell = null;
+    this.healthCheckInterval = null;
+    this.regionLatencyMap = /* @__PURE__ */ new Map();
+    this.config = config;
+    this.storage = storage;
+    if (config.cellEndpoints.length > 0) {
+      this.initializeCellularArchitecture();
+    }
+  }
+  async initializeCellularArchitecture() {
+    const cachedCell = this.loadCachedCell();
+    if (cachedCell && this.isCellHealthy(cachedCell)) {
+      this.activeCell = cachedCell;
+      logger.info("Using cached cell:", cachedCell);
+    } else {
+      await this.selectOptimalCell();
+    }
+    this.startHealthChecks();
+  }
+  loadCachedCell() {
+    const cached = this.storage.get("active_cell");
+    if (!cached) {
+      return null;
+    }
+    try {
+      return JSON.parse(cached);
+    } catch (error) {
+      logger.warn("Failed to parse cached cell:", error);
+      return null;
+    }
+  }
+  saveCachedCell(cell) {
+    this.storage.set("active_cell", JSON.stringify(cell), 7);
+  }
+  isCellHealthy(cell) {
+    return cell.healthy && this.config.cellEndpoints.some(
+      (c) => c.region === cell.region && c.url === cell.url
+    );
+  }
+  async selectOptimalCell() {
+    logger.info("Selecting optimal cell...");
+    if (this.config.preferredRegion) {
+      const preferredCell = this.config.cellEndpoints.find(
+        (cell) => cell.region === this.config.preferredRegion && cell.healthy
+      );
+      if (preferredCell) {
+        this.activeCell = preferredCell;
+        this.saveCachedCell(preferredCell);
+        logger.info("Using preferred region cell:", preferredCell);
+        return;
+      }
+    }
+    if (this.config.autoRegionDetection) {
+      await this.detectOptimalRegion();
+    } else {
+      this.selectCellByPriority();
+    }
+  }
+  async detectOptimalRegion() {
+    const healthyCells = this.config.cellEndpoints.filter((cell) => cell.healthy);
+    if (healthyCells.length === 0) {
+      logger.error("No healthy cells available");
+      return;
+    }
+    const latencyPromises = healthyCells.map(async (cell) => {
+      const latency = await this.measureLatency(cell);
+      this.regionLatencyMap.set(cell.region, latency);
+      return { cell, latency };
+    });
+    const results = await Promise.all(latencyPromises);
+    results.sort((a, b) => a.latency - b.latency);
+    const optimalCell = results[0].cell;
+    this.activeCell = optimalCell;
+    this.saveCachedCell(optimalCell);
+    logger.info("Optimal cell selected:", {
+      region: optimalCell.region,
+      latency: results[0].latency
+    });
+  }
+  async measureLatency(cell) {
+    const startTime = performance.now();
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 2e3);
+      const response = await fetch(`${cell.url}/health`, {
+        method: "GET",
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.ok) {
+        return performance.now() - startTime;
+      } else {
+        return Infinity;
+      }
+    } catch (error) {
+      logger.warn(`Health check failed for ${cell.region}:`, error);
+      return Infinity;
+    }
+  }
+  selectCellByPriority() {
+    const sortedCells = [...this.config.cellEndpoints].filter((cell) => cell.healthy).sort((a, b) => a.priority - b.priority);
+    if (sortedCells.length > 0) {
+      this.activeCell = sortedCells[0];
+      this.saveCachedCell(sortedCells[0]);
+      logger.info("Cell selected by priority:", sortedCells[0]);
+    } else {
+      logger.error("No healthy cells available");
+    }
+  }
+  startHealthChecks() {
+    this.healthCheckInterval = window.setInterval(() => {
+      this.performHealthChecks();
+    }, 6e4);
+  }
+  async performHealthChecks() {
+    const healthPromises = this.config.cellEndpoints.map(async (cell) => {
+      const isHealthy = await this.checkCellHealth(cell);
+      cell.healthy = isHealthy;
+      return { cell, isHealthy };
+    });
+    const results = await Promise.all(healthPromises);
+    if (this.activeCell && !this.activeCell.healthy) {
+      logger.warn("Active cell unhealthy, selecting new cell");
+      await this.selectOptimalCell();
+    }
+    logger.debug("Health check results:", results);
+  }
+  async checkCellHealth(cell) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 3e3);
+      const response = await fetch(`${cell.url}/health`, {
+        method: "GET",
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      return response.ok;
+    } catch (error) {
+      return false;
+    }
+  }
+  async send(events) {
+    if (events.length === 0) {
+      return { success: true };
+    }
+    const endpoint = this.getActiveEndpoint();
+    const payload = this.buildPayload(events);
+    logger.debug("Sending batch:", { endpoint, eventCount: events.length });
+    if (document.visibilityState === "hidden" && typeof navigator.sendBeacon === "function") {
+      const result = this.sendViaBeacon(endpoint, payload);
+      return Promise.resolve(result);
+    } else {
+      return this.sendViaFetch(endpoint, payload);
+    }
+  }
+  getActiveEndpoint() {
+    if (this.activeCell) {
+      return `${this.activeCell.url}/v1/batch`;
+    }
+    if (this.config.apiHost) {
+      return `${this.config.apiHost}/v1/batch`;
+    }
+    throw new Error("No active endpoint available");
+  }
+  buildPayload(events) {
+    return {
+      batch: events,
+      sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+      writeKey: this.config.writeKey,
+      context: this.activeCell ? {
+        cell: {
+          region: this.activeCell.region,
+          endpoint: this.activeCell.url
+        }
+      } : void 0
+    };
+  }
+  sendViaBeacon(endpoint, payload) {
+    try {
+      const blob = new Blob([JSON.stringify(payload)], {
+        type: "application/json"
+      });
+      const sent = navigator.sendBeacon(endpoint, blob);
+      if (sent) {
+        logger.debug("Batch sent via Beacon");
+        return { success: true, endpoint };
+      } else {
+        logger.warn("Beacon send failed, falling back to fetch");
+        return this.sendViaFetch(endpoint, payload);
+      }
+    } catch (error) {
+      logger.error("Beacon send error:", error);
+      return {
+        success: false,
+        error,
+        endpoint
+      };
+    }
+  }
+  async sendViaFetch(endpoint, payload, attempt = 1) {
+    try {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(
+        () => controller.abort(),
+        this.config.requestTimeout
+      );
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.writeKey}`
+        },
+        body: JSON.stringify(payload),
+        keepalive: true,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.ok) {
+        const result = await response.json();
+        logger.debug("Batch sent successfully:", result);
+        return { success: true, response: result, endpoint };
+      } else {
+        const errorText = await response.text();
+        const error = new Error(
+          `HTTP ${response.status}: ${errorText || response.statusText}`
+        );
+        logger.error("Batch send failed:", error);
+        if (this.shouldRetry(response.status, attempt)) {
+          return this.retryRequest(endpoint, payload, attempt);
+        }
+        return { success: false, error, endpoint };
+      }
+    } catch (error) {
+      logger.error("Fetch error:", error);
+      if (this.shouldRetry(0, attempt)) {
+        return this.retryRequest(endpoint, payload, attempt);
+      }
+      return {
+        success: false,
+        error,
+        endpoint
+      };
+    }
+  }
+  shouldRetry(statusCode, attempt) {
+    if (!this.config.retryFailedRequests) {
+      return false;
+    }
+    if (attempt >= this.config.maxRetries) {
+      return false;
+    }
+    if (statusCode === 0) {
+      return true;
+    }
+    return statusCode >= 500 || statusCode === 429;
+  }
+  async retryRequest(endpoint, payload, attempt) {
+    const delay = Math.pow(this.config.retryBackoffMultiplier, attempt) * 1e3;
+    logger.info(`Retrying request in ${delay}ms (attempt ${attempt + 1})`);
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    return this.sendViaFetch(endpoint, payload, attempt + 1);
+  }
+  getActiveCell() {
+    return this.activeCell;
+  }
+  getRegionLatencies() {
+    return new Map(this.regionLatencyMap);
+  }
+  destroy() {
+    if (this.healthCheckInterval) {
+      clearInterval(this.healthCheckInterval);
+      this.healthCheckInterval = null;
+    }
+  }
+}
+const STORAGE_PREFIX = "aegis_";
+class Storage {
+  constructor(options = {}) {
+    this.options = options;
+    this.useLocalStorage = this.isLocalStorageAvailable();
+  }
+  isLocalStorageAvailable() {
+    try {
+      const test = "__aegis_test__";
+      localStorage.setItem(test, test);
+      localStorage.removeItem(test);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  set(key, value, expiryDays = 365) {
+    const fullKey = STORAGE_PREFIX + key;
+    if (this.useLocalStorage) {
+      try {
+        const item = {
+          value,
+          expiry: Date.now() + expiryDays * 24 * 60 * 60 * 1e3
+        };
+        localStorage.setItem(fullKey, JSON.stringify(item));
+      } catch (error) {
+        console.warn("[Active Reach Storage] localStorage.setItem failed:", error);
+      }
+    }
+    this.setCookie(fullKey, value, expiryDays);
+  }
+  get(key) {
+    const fullKey = STORAGE_PREFIX + key;
+    if (this.useLocalStorage) {
+      try {
+        const itemStr = localStorage.getItem(fullKey);
+        if (itemStr) {
+          const item = JSON.parse(itemStr);
+          if (Date.now() < item.expiry) {
+            return item.value;
+          } else {
+            localStorage.removeItem(fullKey);
+          }
+        }
+      } catch (error) {
+        console.warn("[Active Reach Storage] localStorage.getItem failed:", error);
+      }
+    }
+    return this.getCookie(fullKey);
+  }
+  remove(key) {
+    const fullKey = STORAGE_PREFIX + key;
+    if (this.useLocalStorage) {
+      try {
+        localStorage.removeItem(fullKey);
+      } catch (error) {
+        console.warn("[Active Reach Storage] localStorage.removeItem failed:", error);
+      }
+    }
+    this.deleteCookie(fullKey);
+  }
+  clear() {
+    if (this.useLocalStorage) {
+      try {
+        const keys = Object.keys(localStorage);
+        keys.forEach((key) => {
+          if (key.startsWith(STORAGE_PREFIX)) {
+            localStorage.removeItem(key);
+          }
+        });
+      } catch (error) {
+        console.warn("[Active Reach Storage] localStorage.clear failed:", error);
+      }
+    }
+    const cookies = document.cookie.split(";");
+    cookies.forEach((cookie) => {
+      const key = cookie.split("=")[0].trim();
+      if (key.startsWith(STORAGE_PREFIX)) {
+        this.deleteCookie(key);
+      }
+    });
+  }
+  setCookie(name, value, days) {
+    try {
+      const date = /* @__PURE__ */ new Date();
+      date.setTime(date.getTime() + days * 24 * 60 * 60 * 1e3);
+      const expires = `expires=${date.toUTCString()}`;
+      let cookieStr = `${name}=${value};${expires};path=/`;
+      if (this.options.secureCookie && window.location.protocol === "https:") {
+        cookieStr += ";Secure";
+      }
+      cookieStr += ";SameSite=Lax";
+      if (this.options.cookieDomain) {
+        cookieStr += `;domain=${this.options.cookieDomain}`;
+      } else if (this.options.crossDomain) {
+        const domain = this.getRootDomain();
+        if (domain) {
+          cookieStr += `;domain=${domain}`;
+        }
+      }
+      document.cookie = cookieStr;
+    } catch (error) {
+      console.warn("[Active Reach Storage] setCookie failed:", error);
+    }
+  }
+  getCookie(name) {
+    try {
+      const nameEQ = name + "=";
+      const ca = document.cookie.split(";");
+      for (let i = 0; i < ca.length; i++) {
+        let c = ca[i];
+        while (c.charAt(0) === " ") {
+          c = c.substring(1, c.length);
+        }
+        if (c.indexOf(nameEQ) === 0) {
+          return c.substring(nameEQ.length, c.length);
+        }
+      }
+    } catch (error) {
+      console.warn("[Active Reach Storage] getCookie failed:", error);
+    }
+    return null;
+  }
+  deleteCookie(name) {
+    try {
+      let cookieStr = `${name}=;expires=Thu, 01 Jan 1970 00:00:00 UTC;path=/`;
+      if (this.options.cookieDomain) {
+        cookieStr += `;domain=${this.options.cookieDomain}`;
+      } else if (this.options.crossDomain) {
+        const domain = this.getRootDomain();
+        if (domain) {
+          cookieStr += `;domain=${domain}`;
+        }
+      }
+      document.cookie = cookieStr;
+    } catch (error) {
+      console.warn("[Active Reach Storage] deleteCookie failed:", error);
+    }
+  }
+  getRootDomain() {
+    try {
+      const hostname = window.location.hostname;
+      if (/^(\d{1,3}\.){3}\d{1,3}$/.test(hostname)) {
+        return null;
+      }
+      if (hostname === "localhost") {
+        return null;
+      }
+      const parts = hostname.split(".");
+      if (parts.length <= 2) {
+        return `.${hostname}`;
+      }
+      return `.${parts.slice(-2).join(".")}`;
+    } catch (error) {
+      console.warn("[Active Reach Storage] getRootDomain failed:", error);
+      return null;
+    }
+  }
+}
+const CREDENTIAL_URL_PARAMS = [
+  "t",
+  "k",
+  "code",
+  "session_code",
+  "aegis_pair",
+  "u",
+  // The Shopify CarrierService callback token (2026-09-18). Server-to-server
+  // today, so the SDK never sees one — it is here because the two lists are
+  // ONE rule, and a list that is only correct for today's callers is not.
+  "carrier_token"
+];
+const REDACTED = "REDACTED";
+const CREDENTIAL_PARAM_PATTERN = new RegExp(
+  `([?&])(${CREDENTIAL_URL_PARAMS.join("|")})=([^&#\\s"'<>]+)`,
+  "g"
+);
+function redactUrl(value) {
+  if (typeof value !== "string" || value.length === 0) return value;
+  try {
+    return value.replace(CREDENTIAL_PARAM_PATTERN, `$1$2=${REDACTED}`);
+  } catch {
+    return value;
+  }
+}
+function parseUTMParameters(url) {
+  try {
+    const searchParams = url ? new URL(url).searchParams : new URLSearchParams(window.location.search);
+    const utm = {};
+    const utmKeys = [
+      "source",
+      "medium",
+      "campaign",
+      "term",
+      "content",
+      "name"
+    ];
+    utmKeys.forEach((key) => {
+      const value = searchParams.get(`utm_${key}`);
+      if (value) {
+        utm[key] = value;
+      }
+    });
+    return utm;
+  } catch (error) {
+    console.warn("[Active Reach URL Parser] parseUTMParameters failed:", error);
+    return {};
+  }
+}
+function parseAdClickIDs(url) {
+  try {
+    const searchParams = url ? new URL(url).searchParams : new URLSearchParams(window.location.search);
+    const adClickIDs = {};
+    const clickIDKeys = [
+      "gclid",
+      "gbraid",
+      "wbraid",
+      "fbclid",
+      "msclkid",
+      "ctwa_clid",
+      "ttclid",
+      "li_fat_id"
+    ];
+    clickIDKeys.forEach((key) => {
+      const value = searchParams.get(key);
+      if (value) {
+        adClickIDs[key] = value;
+      }
+    });
+    return adClickIDs;
+  } catch (error) {
+    console.warn("[Active Reach URL Parser] parseAdClickIDs failed:", error);
+    return {};
+  }
+}
+function hasAdClickIDs(adClickIDs) {
+  return Object.keys(adClickIDs).length > 0;
+}
+const LINK_ATTRIBUTION_KEYS = [
+  "aegis_code",
+  "aegis_campaign",
+  "aegis_journey",
+  "aegis_playbook",
+  "aegis_button"
+];
+function parseLinkAttribution(url) {
+  try {
+    const searchParams = url ? new URL(url).searchParams : new URLSearchParams(window.location.search);
+    if (!searchParams.get("aegis_code")) return {};
+    const attribution = {};
+    LINK_ATTRIBUTION_KEYS.forEach((key) => {
+      const value = searchParams.get(key);
+      if (value) {
+        attribution[key] = value;
+      }
+    });
+    return attribution;
+  } catch (error) {
+    console.warn("[Active Reach URL Parser] parseLinkAttribution failed:", error);
+    return {};
+  }
+}
+function buildContext(config, session) {
+  const utm = config.capture_utm ? parseUTMParameters() : void 0;
+  const device = detectDevice();
+  const os = detectOS();
+  const browser = detectBrowser();
+  const network = detectNetworkInfo();
+  const adClickIDs = session == null ? void 0 : session.getAdClickIDs();
+  const storedLandingPage = session == null ? void 0 : session.getLandingPage();
+  const landingPage = storedLandingPage ? redactUrl(storedLandingPage) : void 0;
+  return {
+    library: {
+      name: "@active-reach/web-sdk",
+      version: "1.0.0"
+    },
+    // Credential params (`k`, `t`, `code`, ...) keep their key and lose their
+    // value here, where the URL enters the page object. The referrer is
+    // redacted too: the previous page can be our own order/landing link.
+    page: {
+      path: window.location.pathname,
+      referrer: config.capture_referrer ? redactUrl(document.referrer) : "",
+      search: redactUrl(window.location.search),
+      title: document.title,
+      url: redactUrl(window.location.href),
+      hash: window.location.hash
+    },
+    userAgent: navigator.userAgent,
+    locale: navigator.language,
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    screen: {
+      width: window.screen.width,
+      height: window.screen.height,
+      density: window.devicePixelRatio || 1
+    },
+    viewport: {
+      width: window.innerWidth,
+      height: window.innerHeight
+    },
+    ...utm && Object.keys(utm).length > 0 && { campaign: utm },
+    ...adClickIDs && Object.keys(adClickIDs).length > 0 && { adClickIDs },
+    ...landingPage && { landingPage },
+    ...network && { network },
+    ...device && { device },
+    ...os && { os },
+    ...browser && { browser },
+    ...config.active_cell && {
+      cell: {
+        region: config.active_cell.region,
+        endpoint: config.active_cell.url
+      }
+    }
+  };
+}
+function detectDevice() {
+  const ua = navigator.userAgent;
+  if (/(tablet|ipad|playbook|silk)|(android(?!.*mobi))/i.test(ua)) {
+    return { type: "tablet" };
+  }
+  if (/Mobile|Android|iP(hone|od)|IEMobile|BlackBerry|Kindle|Silk-Accelerated|(hpw|web)OS|Opera M(obi|ini)/.test(ua)) {
+    return { type: "mobile" };
+  }
+  return { type: "desktop" };
+}
+function detectOS() {
+  const ua = navigator.userAgent;
+  if (/Windows NT 10/i.test(ua)) return { name: "Windows", version: "10" };
+  if (/Windows NT 6.3/i.test(ua)) return { name: "Windows", version: "8.1" };
+  if (/Windows NT 6.2/i.test(ua)) return { name: "Windows", version: "8" };
+  if (/Windows NT 6.1/i.test(ua)) return { name: "Windows", version: "7" };
+  if (/Windows/i.test(ua)) return { name: "Windows", version: "Unknown" };
+  if (/Mac OS X (\d+)[._](\d+)/.test(ua)) {
+    const match = ua.match(/Mac OS X (\d+)[._](\d+)/);
+    return { name: "macOS", version: `${match[1]}.${match[2]}` };
+  }
+  if (/Mac/i.test(ua)) return { name: "macOS", version: "Unknown" };
+  if (/Android (\d+\.\d+)/.test(ua)) {
+    const match = ua.match(/Android (\d+\.\d+)/);
+    return { name: "Android", version: match[1] };
+  }
+  if (/Android/i.test(ua)) return { name: "Android", version: "Unknown" };
+  if (/iPhone OS (\d+)_(\d+)/.test(ua)) {
+    const match = ua.match(/iPhone OS (\d+)_(\d+)/);
+    return { name: "iOS", version: `${match[1]}.${match[2]}` };
+  }
+  if (/iPad.*OS (\d+)_(\d+)/.test(ua)) {
+    const match = ua.match(/iPad.*OS (\d+)_(\d+)/);
+    return { name: "iOS", version: `${match[1]}.${match[2]}` };
+  }
+  if (/iPhone|iPad/i.test(ua)) return { name: "iOS", version: "Unknown" };
+  if (/Linux/i.test(ua)) return { name: "Linux", version: "Unknown" };
+  return { name: "Unknown", version: "Unknown" };
+}
+function detectBrowser() {
+  const ua = navigator.userAgent;
+  if (/Edg\/(\d+\.\d+)/.test(ua)) {
+    const match = ua.match(/Edg\/(\d+\.\d+)/);
+    return { name: "Edge", version: match[1] };
+  }
+  if (/Chrome\/(\d+\.\d+)/.test(ua) && !/Edg/.test(ua)) {
+    const match = ua.match(/Chrome\/(\d+\.\d+)/);
+    return { name: "Chrome", version: match[1] };
+  }
+  if (/Firefox\/(\d+\.\d+)/.test(ua)) {
+    const match = ua.match(/Firefox\/(\d+\.\d+)/);
+    return { name: "Firefox", version: match[1] };
+  }
+  if (/Safari\/(\d+\.\d+)/.test(ua) && !/Chrome/.test(ua)) {
+    const match = ua.match(/Version\/(\d+\.\d+)/);
+    return { name: "Safari", version: match ? match[1] : "Unknown" };
+  }
+  if (/MSIE (\d+\.\d+)/.test(ua) || /Trident\//.test(ua)) {
+    const match = ua.match(/MSIE (\d+\.\d+)/) || ua.match(/rv:(\d+\.\d+)/);
+    return { name: "Internet Explorer", version: match ? match[1] : "Unknown" };
+  }
+  return { name: "Unknown", version: "Unknown" };
+}
+function detectNetworkInfo() {
+  try {
+    const connection = navigator.connection || navigator.mozConnection || navigator.webkitConnection;
+    if (connection) {
+      return {
+        effectiveType: connection.effectiveType,
+        downlink: connection.downlink,
+        rtt: connection.rtt
+      };
+    }
+  } catch (error) {
+    console.warn("[Active Reach Device] detectNetworkInfo failed:", error);
+  }
+  return void 0;
+}
+function isBot() {
+  const ua = navigator.userAgent.toLowerCase();
+  const botPatterns = [
+    "bot",
+    "crawl",
+    "spider",
+    "slurp",
+    "mediapartners",
+    "googlebot",
+    "bingbot",
+    "yahoo",
+    "duckduckbot",
+    "baiduspider",
+    "yandex",
+    "facebookexternalhit",
+    "linkedinbot",
+    "twitterbot",
+    "slackbot",
+    "telegrambot",
+    "whatsapp",
+    "pingdom",
+    "uptimerobot"
+  ];
+  return botPatterns.some((pattern) => ua.includes(pattern));
+}
+class PluginRegistry {
+  constructor() {
+    this.plugins = /* @__PURE__ */ new Map();
+  }
+  register(plugin) {
+    if (this.plugins.has(plugin.name)) {
+      logger.warn(`Plugin "${plugin.name}" already registered, skipping`);
+      return;
+    }
+    this.plugins.set(plugin.name, plugin);
+    logger.info(`Plugin registered: ${plugin.name} v${plugin.version}`);
+  }
+  unregister(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) {
+      logger.warn(`Plugin "${pluginName}" not found`);
+      return;
+    }
+    if (plugin.destroy) {
+      try {
+        plugin.destroy();
+      } catch (error) {
+        logger.error(`Error destroying plugin "${pluginName}":`, error);
+      }
+    }
+    this.plugins.delete(pluginName);
+    logger.info(`Plugin unregistered: ${pluginName}`);
+  }
+  get(pluginName) {
+    return this.plugins.get(pluginName);
+  }
+  getAll() {
+    return Array.from(this.plugins.values());
+  }
+  async executeHook(hookName, ...args) {
+    for (const plugin of this.plugins.values()) {
+      const hook = plugin[hookName];
+      if (typeof hook === "function") {
+        try {
+          const result = await hook.apply(plugin, args);
+          if (result !== void 0) {
+            return result;
+          }
+        } catch (error) {
+          logger.error(
+            `Error executing ${String(hookName)} in plugin "${plugin.name}":`,
+            error
+          );
+          if (plugin.onError) {
+            try {
+              plugin.onError(error, { hookName, args });
+            } catch (onErrorError) {
+              logger.error(
+                `Error in onError handler for plugin "${plugin.name}":`,
+                onErrorError
+              );
+            }
+          }
+        }
+      }
+    }
+    return void 0;
+  }
+  async executeHookChain(hookName, initialValue, ...additionalArgs) {
+    let value = initialValue;
+    for (const plugin of this.plugins.values()) {
+      const hook = plugin[hookName];
+      if (typeof hook === "function") {
+        try {
+          const result = await hook.apply(plugin, [
+            value,
+            ...additionalArgs
+          ]);
+          if (result !== void 0 && result !== null) {
+            value = result;
+          }
+        } catch (error) {
+          logger.error(
+            `Error executing ${String(hookName)} in plugin "${plugin.name}":`,
+            error
+          );
+          if (plugin.onError) {
+            try {
+              plugin.onError(error, { hookName, value, additionalArgs });
+            } catch (onErrorError) {
+              logger.error(
+                `Error in onError handler for plugin "${plugin.name}":`,
+                onErrorError
+              );
+            }
+          }
+        }
+      }
+    }
+    return value;
+  }
+  async executeHookParallel(hookName, ...args) {
+    const promises = [];
+    for (const plugin of this.plugins.values()) {
+      const hook = plugin[hookName];
+      if (typeof hook === "function") {
+        const promise = (async () => {
+          try {
+            return await hook.apply(plugin, args);
+          } catch (error) {
+            logger.error(
+              `Error executing ${String(hookName)} in plugin "${plugin.name}":`,
+              error
+            );
+            if (plugin.onError) {
+              try {
+                plugin.onError(error, { hookName, args });
+              } catch (onErrorError) {
+                logger.error(
+                  `Error in onError handler for plugin "${plugin.name}":`,
+                  onErrorError
+                );
+              }
+            }
+            return void 0;
+          }
+        })();
+        promises.push(promise);
+      }
+    }
+    const results = await Promise.all(promises);
+    return results.filter((r) => r !== void 0);
+  }
+  clear() {
+    for (const plugin of this.plugins.values()) {
+      if (plugin.destroy) {
+        try {
+          plugin.destroy();
+        } catch (error) {
+          logger.error(`Error destroying plugin "${plugin.name}":`, error);
+        }
+      }
+    }
+    this.plugins.clear();
+    logger.info("All plugins cleared");
+  }
+}
+class ConsentManager {
+  constructor(storage, config = {}) {
+    this.listeners = [];
+    this.storage = storage;
+    this.config = {
+      defaultConsent: config.defaultConsent || {},
+      waitForConsent: config.waitForConsent ?? false,
+      consentStorageKey: config.consentStorageKey || "aegis_consent"
+    };
+    this.preferences = this.loadPreferences();
+  }
+  loadPreferences() {
+    const stored = this.storage.get(this.config.consentStorageKey);
+    if (stored) {
+      try {
+        const parsed = JSON.parse(stored);
+        logger.info("Loaded consent preferences:", parsed);
+        return this.mergeWithDefaults(parsed);
+      } catch (error) {
+        logger.warn("Failed to parse consent preferences:", error);
+      }
+    }
+    return this.getDefaultPreferences();
+  }
+  getDefaultPreferences() {
+    return {
+      analytics: this.config.defaultConsent.analytics ?? false,
+      marketing: this.config.defaultConsent.marketing ?? false,
+      functional: this.config.defaultConsent.functional ?? true,
+      necessary: true
+    };
+  }
+  mergeWithDefaults(preferences) {
+    return {
+      necessary: true,
+      analytics: preferences.analytics ?? this.config.defaultConsent.analytics ?? false,
+      marketing: preferences.marketing ?? this.config.defaultConsent.marketing ?? false,
+      functional: preferences.functional ?? this.config.defaultConsent.functional ?? true
+    };
+  }
+  savePreferences() {
+    try {
+      this.storage.set(
+        this.config.consentStorageKey,
+        JSON.stringify(this.preferences),
+        365
+      );
+      logger.info("Saved consent preferences:", this.preferences);
+    } catch (error) {
+      logger.error("Failed to save consent preferences:", error);
+    }
+  }
+  setConsent(preferences) {
+    const updated = { ...this.preferences, ...preferences };
+    updated.necessary = true;
+    this.preferences = updated;
+    this.savePreferences();
+    this.notifyListeners();
+    logger.info("Consent updated:", this.preferences);
+  }
+  grantAll() {
+    this.setConsent({
+      analytics: true,
+      marketing: true,
+      functional: true,
+      necessary: true
+    });
+  }
+  denyAll() {
+    this.setConsent({
+      analytics: false,
+      marketing: false,
+      functional: false,
+      necessary: true
+    });
+  }
+  hasConsent(category) {
+    return this.preferences[category];
+  }
+  getPreferences() {
+    return { ...this.preferences };
+  }
+  getStatus(category) {
+    if (this.hasConsent(category)) {
+      return "granted";
+    }
+    const stored = this.storage.get(this.config.consentStorageKey);
+    if (!stored && this.config.waitForConsent) {
+      return "pending";
+    }
+    return "denied";
+  }
+  isAnalyticsEnabled() {
+    return this.hasConsent("analytics");
+  }
+  isMarketingEnabled() {
+    return this.hasConsent("marketing");
+  }
+  onChange(callback) {
+    this.listeners.push(callback);
+    return () => {
+      const index = this.listeners.indexOf(callback);
+      if (index > -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+  notifyListeners() {
+    this.listeners.forEach((listener) => {
+      try {
+        listener(this.getPreferences());
+      } catch (error) {
+        logger.error("Consent listener error:", error);
+      }
+    });
+  }
+  reset() {
+    this.storage.remove(this.config.consentStorageKey);
+    this.preferences = this.getDefaultPreferences();
+    this.notifyListeners();
+    logger.info("Consent preferences reset");
+  }
+  integrateOneTrust() {
+    if (typeof window === "undefined") return;
+    const oneTrust = window.OneTrust;
+    if (!oneTrust) {
+      logger.warn("OneTrust not detected");
+      return;
+    }
+    const syncWithOneTrust = () => {
+      const activeGroups = window.OnetrustActiveGroups || "";
+      this.setConsent({
+        necessary: true,
+        functional: activeGroups.includes("C0003"),
+        analytics: activeGroups.includes("C0002"),
+        marketing: activeGroups.includes("C0004")
+      });
+      logger.info("Synced with OneTrust consent");
+    };
+    if (window.OptanonWrapper) {
+      const originalWrapper = window.OptanonWrapper;
+      window.OptanonWrapper = function() {
+        originalWrapper();
+        syncWithOneTrust();
+      };
+    } else {
+      window.OptanonWrapper = syncWithOneTrust;
+    }
+    syncWithOneTrust();
+  }
+  integrateCookiebot() {
+    if (typeof window === "undefined") return;
+    const cookiebot = window.Cookiebot;
+    if (!cookiebot) {
+      logger.warn("Cookiebot not detected");
+      return;
+    }
+    const syncWithCookiebot = () => {
+      const consent = cookiebot.consent || {};
+      this.setConsent({
+        necessary: true,
+        functional: consent.preferences || false,
+        analytics: consent.statistics || false,
+        marketing: consent.marketing || false
+      });
+      logger.info("Synced with Cookiebot consent");
+    };
+    window.addEventListener("CookiebotOnAccept", syncWithCookiebot);
+    window.addEventListener("CookiebotOnDecline", syncWithCookiebot);
+    if (cookiebot.consent) {
+      syncWithCookiebot();
+    }
+  }
+  integrateGoogleConsentMode() {
+    if (typeof window === "undefined") return;
+    const w = window;
+    if (typeof w.gtag !== "function") {
+      w.dataLayer = w.dataLayer ?? [];
+      w.gtag = (...args) => {
+        var _a;
+        (_a = w.dataLayer) == null ? void 0 : _a.push(args);
+      };
+      logger.debug("Google tag not yet loaded — queuing consent via dataLayer");
+    }
+    const gtag = w.gtag;
+    const updateGoogleConsent = () => {
+      gtag("consent", "update", {
+        ad_storage: this.preferences.marketing ? "granted" : "denied",
+        analytics_storage: this.preferences.analytics ? "granted" : "denied",
+        ad_user_data: this.preferences.marketing ? "granted" : "denied",
+        ad_personalization: this.preferences.marketing ? "granted" : "denied",
+        functionality_storage: this.preferences.functional ? "granted" : "denied",
+        personalization_storage: this.preferences.functional ? "granted" : "denied",
+        security_storage: "granted"
+      });
+      logger.debug("Updated Google Consent Mode");
+    };
+    this.onChange(updateGoogleConsent);
+    updateGoogleConsent();
+  }
+}
+function sumItems(products) {
+  return products.reduce((sum, p) => sum + (p.quantity ?? 1), 0);
+}
+function mapProducts(products) {
+  return products.map((p) => ({
+    product_id: p.product_id,
+    sku: p.sku,
+    name: p.name,
+    price: p.price,
+    quantity: p.quantity ?? 1,
+    currency: p.currency,
+    category: p.category,
+    brand: p.brand,
+    variant_id: p.variant_id,
+    variant_label: p.variant_label,
+    position: p.position
+  }));
+}
+class EcommerceTracker {
+  constructor(aegis) {
+    this.aegis = aegis;
+    this._cart = {
+      total: 0,
+      itemCount: 0,
+      currency: "INR"
+    };
+    this._cartSink = null;
+  }
+  /** Register a sink that receives the derived cart on every cart event.
+   *  Wired once by `AegisMessageRuntime.bindEcommerce(...)`. Emits the current
+   *  snapshot immediately so a late binding still gets the latest cart. */
+  onCartChange(sink) {
+    this._cartSink = sink;
+    sink({ ...this._cart });
+  }
+  _emitCart() {
+    var _a;
+    if (this._cart.total < 0) this._cart.total = 0;
+    if (this._cart.itemCount < 0) this._cart.itemCount = 0;
+    (_a = this._cartSink) == null ? void 0 : _a.call(this, { ...this._cart });
+  }
+  // -- Product Discovery --
+  productViewed(product) {
+    this.aegis.track("product_viewed", {
+      product_id: product.product_id,
+      sku: product.sku,
+      name: product.name,
+      price: product.price,
+      currency: product.currency ?? "INR",
+      category: product.category,
+      brand: product.brand,
+      variant_id: product.variant_id,
+      variant_label: product.variant_label,
+      image_url: product.image_url,
+      url: product.url
+    });
+  }
+  productListViewed(list) {
+    const products = mapProducts(list.products);
+    this.aegis.track("product_list_viewed", {
+      list_id: list.list_id,
+      list_name: list.list_name,
+      category: list.category,
+      products,
+      // `items` as well as `products` — a THIRD spelling of the same fact was
+      // one spelling too many. Every product reader in the platform looks for
+      // `items` (or `line_items`, the Shopify shape); this event alone said
+      // `products`, so a list view showed N products and contributed nothing to
+      // any of them. On ST that was 4 views recorded as `not measured`, and it
+      // is the same defect that made every Shopify order invisible.
+      //
+      // `products` is kept so nothing already reading it breaks. mapProducts
+      // already emits product_id / sku / name / price / quantity, which is
+      // exactly the canonical item shape — no second mapping to drift.
+      items: products
+    });
+  }
+  productClicked(product, source) {
+    this.aegis.track("product_clicked", {
+      product_id: product.product_id,
+      sku: product.sku,
+      name: product.name,
+      price: product.price,
+      currency: product.currency ?? "INR",
+      category: product.category,
+      brand: product.brand,
+      variant_id: product.variant_id,
+      list_id: source == null ? void 0 : source.list_id,
+      position: (source == null ? void 0 : source.position) ?? product.position,
+      section: source == null ? void 0 : source.section
+    });
+  }
+  productImpressed(product, source) {
+    this.aegis.track("product_impression", {
+      product_id: product.product_id,
+      sku: product.sku,
+      name: product.name,
+      price: product.price,
+      currency: product.currency ?? "INR",
+      category: product.category,
+      list_id: source == null ? void 0 : source.list_id,
+      position: (source == null ? void 0 : source.position) ?? product.position,
+      section: source == null ? void 0 : source.section
+    });
+  }
+  categoryFiltered(category, options) {
+    this.aegis.track("category_filtered", {
+      category,
+      previous_category: options == null ? void 0 : options.previous_category,
+      result_count: options == null ? void 0 : options.result_count
+    });
+  }
+  searchPerformed(search) {
+    this.aegis.track("search_performed", {
+      query: search.query,
+      results_count: search.results_count,
+      filters: search.filters
+    });
+  }
+  // -- Cart --
+  addToCart(product) {
+    const qty = product.quantity ?? 1;
+    this.aegis.track("cart_item_added", {
+      product_id: product.product_id,
+      sku: product.sku,
+      name: product.name,
+      price: product.price,
+      quantity: qty,
+      currency: product.currency ?? "INR",
+      category: product.category,
+      brand: product.brand,
+      variant_id: product.variant_id,
+      variant_label: product.variant_label
+    });
+    this._cart.total += (product.price || 0) * qty;
+    this._cart.itemCount += qty;
+    if (product.currency) this._cart.currency = product.currency;
+    this._emitCart();
+  }
+  removeFromCart(product) {
+    const qty = product.quantity ?? 1;
+    this.aegis.track("cart_item_removed", {
+      product_id: product.product_id,
+      sku: product.sku,
+      name: product.name,
+      price: product.price,
+      quantity: qty,
+      currency: product.currency ?? "INR",
+      variant_id: product.variant_id
+    });
+    this._cart.total -= (product.price || 0) * qty;
+    this._cart.itemCount -= qty;
+    this._emitCart();
+  }
+  cartViewed(cart) {
+    this.aegis.track("cart_viewed", {
+      cart_id: cart.cart_id,
+      value: cart.value,
+      currency: cart.currency ?? "INR",
+      num_items: sumItems(cart.products),
+      products: mapProducts(cart.products)
+    });
+    this._cart = {
+      total: cart.value || 0,
+      itemCount: sumItems(cart.products),
+      currency: cart.currency ?? this._cart.currency ?? "INR"
+    };
+    this._emitCart();
+  }
+  // -- Checkout --
+  checkoutStarted(checkout) {
+    this.aegis.track("checkout_started", {
+      checkout_id: checkout.checkout_id,
+      value: checkout.value,
+      currency: checkout.currency ?? "INR",
+      num_items: sumItems(checkout.products),
+      coupon: checkout.coupon,
+      shipping: checkout.shipping,
+      tax: checkout.tax,
+      products: mapProducts(checkout.products)
+    });
+  }
+  checkoutStep(step, options) {
+    this.aegis.track("checkout_step", {
+      step,
+      ...options
+    });
+  }
+  checkoutOption(option) {
+    this.aegis.track("checkout_option", { ...option });
+  }
+  // -- Order --
+  orderCompleted(order) {
+    this.aegis.track("order_completed", {
+      order_id: order.order_id,
+      value: order.value,
+      revenue: order.revenue ?? order.value,
+      currency: order.currency ?? "INR",
+      num_items: sumItems(order.products),
+      coupon: order.coupon,
+      shipping: order.shipping,
+      tax: order.tax,
+      discount: order.discount,
+      payment_method: order.payment_method,
+      products: mapProducts(order.products)
+    });
+  }
+  orderRefunded(orderId, value, products) {
+    this.aegis.track("order_refunded", {
+      order_id: orderId,
+      value,
+      products: products ? mapProducts(products) : void 0
+    });
+  }
+  orderShipped(orderId, tracking) {
+    this.aegis.track("order_shipped", {
+      order_id: orderId,
+      carrier: tracking == null ? void 0 : tracking.carrier,
+      tracking_code: tracking == null ? void 0 : tracking.tracking_code,
+      tracking_url: tracking == null ? void 0 : tracking.tracking_url
+    });
+  }
+  // -- Coupons --
+  couponApplied(coupon) {
+    this.aegis.track("coupon_applied", { ...coupon });
+  }
+  couponRemoved(coupon) {
+    this.aegis.track("coupon_removed", { ...coupon });
+  }
+  couponDenied(coupon, reason) {
+    this.aegis.track("coupon_denied", { ...coupon, reason });
+  }
+  // -- Wishlist --
+  wishlistItemAdded(wishlist) {
+    this.aegis.track("wishlist_item_added", {
+      wishlist_id: wishlist.wishlist_id,
+      wishlist_name: wishlist.wishlist_name,
+      product_id: wishlist.product.product_id,
+      sku: wishlist.product.sku,
+      name: wishlist.product.name,
+      price: wishlist.product.price,
+      variant_id: wishlist.product.variant_id
+    });
+  }
+  productRemovedFromWishlist(wishlist) {
+    this.aegis.track("wishlist_item_removed", {
+      wishlist_id: wishlist.wishlist_id,
+      wishlist_name: wishlist.wishlist_name,
+      product_id: wishlist.product.product_id,
+      sku: wishlist.product.sku,
+      name: wishlist.product.name,
+      price: wishlist.product.price,
+      variant_id: wishlist.product.variant_id
+    });
+  }
+  // -- Back-in-stock waitlist --
+  //
+  // Server-side substrate: contact_events row keyed on
+  // (organization_id, contact_id, event_name='product_waitlisted',
+  //  event_properties['product_id']). Resolved by
+  // product_event_trigger_service._get_waitlisted_contacts and fanned out via
+  // catalog.back_in_stock journey trigger when stock_event_handler_worker
+  // detects the SKU flipping back into stock.
+  productWaitlisted(waitlist) {
+    this.aegis.track("product_waitlisted", {
+      product_id: waitlist.product.product_id,
+      sku: waitlist.product.sku,
+      variant_id: waitlist.product.variant_id,
+      name: waitlist.product.name,
+      price: waitlist.product.price,
+      channels: waitlist.channels
+    });
+  }
+  // -- Promotions --
+  promotionViewed(promo) {
+    this.aegis.track("promotion_viewed", { ...promo });
+  }
+  promotionClicked(promo) {
+    this.aegis.track("promotion_clicked", { ...promo });
+  }
+}
+class RateLimiter {
+  constructor(options = {}) {
+    this.droppedThisWindow = 0;
+    this.firstDroppedName = null;
+    this.windowFlushTimer = null;
+    this.capacity = Math.max(1, options.burstCapacity ?? 100);
+    this.refillPerSecond = Math.max(1, options.refillPerSecond ?? 20);
+    this.windowMs = options.dropCoalesceWindowMs ?? 1e3;
+    this.onDropBatch = options.onDropBatch;
+    this.tokens = this.capacity;
+    this.lastRefillMs = Date.now();
+  }
+  /**
+   * Try to consume 1 token. Returns true if allowed, false if throttled.
+   * Throttled events are coalesced into a single onDropBatch callback per window.
+   */
+  tryConsume(eventName) {
+    this.refill();
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return true;
+    }
+    this.droppedThisWindow += 1;
+    if (this.firstDroppedName === null) {
+      this.firstDroppedName = eventName;
+      logger.warn(
+        `[Aegis] Rate limit reached — dropping event "${eventName}" and any further events for ${this.windowMs}ms. Burst=${this.capacity}, refill=${this.refillPerSecond}/s.`
+      );
+    }
+    if (!this.windowFlushTimer) {
+      this.windowFlushTimer = setTimeout(() => this.flushWindow(), this.windowMs);
+    }
+    return false;
+  }
+  /** Diagnostics — current token count (rounded down). */
+  getAvailableTokens() {
+    this.refill();
+    return Math.floor(this.tokens);
+  }
+  /** Cleanup. Idempotent. */
+  destroy() {
+    if (this.windowFlushTimer) {
+      clearTimeout(this.windowFlushTimer);
+      this.windowFlushTimer = null;
+    }
+    this.flushWindow();
+  }
+  // ---------------------------------------------------------------------
+  refill() {
+    const now = Date.now();
+    const elapsedSec = (now - this.lastRefillMs) / 1e3;
+    if (elapsedSec <= 0) return;
+    const newTokens = elapsedSec * this.refillPerSecond;
+    this.tokens = Math.min(this.capacity, this.tokens + newTokens);
+    this.lastRefillMs = now;
+  }
+  flushWindow() {
+    if (this.windowFlushTimer) {
+      clearTimeout(this.windowFlushTimer);
+      this.windowFlushTimer = null;
+    }
+    if (this.droppedThisWindow > 0 && this.onDropBatch) {
+      try {
+        this.onDropBatch(this.droppedThisWindow, this.firstDroppedName);
+      } catch (err) {
+        logger.warn("[Active Reach] RateLimiter.onDropBatch threw:", err);
+      }
+    }
+    this.droppedThisWindow = 0;
+    this.firstDroppedName = null;
+  }
+}
+const C1 = 3432918353;
+const C2 = 461845907;
+function murmurhash3_x86_32(input, seed = 0) {
+  const bytes = new TextEncoder().encode(input);
+  return murmurhash3_bytes(bytes, seed);
+}
+function murmurhash3_bytes(bytes, seed = 0) {
+  const len = bytes.length;
+  const nBlocks = Math.floor(len / 4);
+  let h1 = seed >>> 0;
+  for (let i = 0; i < nBlocks; i++) {
+    const offset = i * 4;
+    let k12 = bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24;
+    k12 = Math.imul(k12, C1);
+    k12 = k12 << 15 | k12 >>> 17;
+    k12 = Math.imul(k12, C2);
+    h1 ^= k12;
+    h1 = h1 << 13 | h1 >>> 19;
+    h1 = Math.imul(h1, 5) + 3864292196 >>> 0;
+  }
+  const tailStart = nBlocks * 4;
+  let k1 = 0;
+  const tailLen = len - tailStart;
+  if (tailLen === 3) k1 ^= bytes[tailStart + 2] << 16;
+  if (tailLen >= 2) k1 ^= bytes[tailStart + 1] << 8;
+  if (tailLen >= 1) {
+    k1 ^= bytes[tailStart];
+    k1 = Math.imul(k1, C1);
+    k1 = k1 << 15 | k1 >>> 17;
+    k1 = Math.imul(k1, C2);
+    h1 ^= k1;
+  }
+  h1 ^= len;
+  h1 ^= h1 >>> 16;
+  h1 = Math.imul(h1, 2246822507);
+  h1 ^= h1 >>> 13;
+  h1 = Math.imul(h1, 3266489909);
+  h1 ^= h1 >>> 16;
+  return h1 >>> 0;
+}
+function base64ToBytes(b64) {
+  if (typeof atob !== "undefined") {
+    const bin = atob(b64);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+    return out;
+  }
+  const B = globalThis.Buffer;
+  if (B && typeof B.from === "function") {
+    const buf = B.from(b64, "base64");
+    return new Uint8Array(buf);
+  }
+  throw new Error("No base64 decoder available (neither atob nor Buffer)");
+}
+class BloomFilter {
+  constructor(buf, params) {
+    this.params = params;
+    if ((params.m & params.m - 1) !== 0) {
+      throw new Error(`Bloom filter m must be a power of 2, got ${params.m}`);
+    }
+    if (buf.length !== params.m >> 3) {
+      throw new Error(
+        `Bloom filter buffer size mismatch: expected ${params.m >> 3} bytes, got ${buf.length}`
+      );
+    }
+    this.buf = buf;
+    this.mask = params.m - 1;
+  }
+  /** Build from the wire format (base64 bytes + explicit params). */
+  static fromBase64(bloomB64, params) {
+    const bytes = base64ToBytes(bloomB64);
+    return new BloomFilter(bytes, params);
+  }
+  /**
+   * Returns true if `name` is probably in the set — possibly with the
+   * filter's configured false-positive rate. FALSE is always authoritative.
+   *
+   * FP here means: SDK thinks a name is already registered when it isn't.
+   * That costs one wasted server round-trip (gateway does the exact check
+   * and catches it) — strictly safer than a false-negative, which could
+   * leak a novel name past the SDK.
+   */
+  has(name) {
+    const h1 = murmurhash3_x86_32(name, this.params.seedA);
+    const h2 = murmurhash3_x86_32(name, this.params.seedB);
+    for (let i = 0; i < this.params.k; i++) {
+      const combined = h1 + Math.imul(i, h2) >>> 0;
+      const idx = combined & this.mask;
+      const bit = this.buf[idx >> 3] & 1 << (idx & 7);
+      if (bit === 0) return false;
+    }
+    return true;
+  }
+}
+const SUPPORTED_ALGO = "mmh3_x86_32_km";
+function warnOncePerSession(message) {
+  if (typeof console === "undefined" || typeof console.warn !== "function") return;
+  console.warn(message);
+}
+class NameGovernor {
+  constructor() {
+    this.bloom = null;
+    this.remainingNewNames = Infinity;
+    this.graceActive = false;
+    this.localNovelNames = /* @__PURE__ */ new Set();
+    this.droppedSinceLastReport = /* @__PURE__ */ new Map();
+    this.reportWindowStart = Date.now();
+    this.hasWarnedThisSession = false;
+  }
+  /**
+   * Ingest a freshly-bootstrapped hint. Call on every successful bootstrap.
+   * Passing `null` disables governance (fail-open).
+   */
+  ingestHint(hint) {
+    if (!hint || hint.bloom_algo !== SUPPORTED_ALGO) {
+      this.bloom = null;
+      this.remainingNewNames = Infinity;
+      this.graceActive = false;
+      this.localNovelNames.clear();
+      return;
+    }
+    try {
+      this.bloom = BloomFilter.fromBase64(hint.bloom_b64, {
+        m: hint.m,
+        k: hint.k,
+        seedA: hint.seed_a,
+        seedB: hint.seed_b
+      });
+    } catch {
+      this.bloom = null;
+    }
+    this.remainingNewNames = hint.remaining_new_names ?? Infinity;
+    this.graceActive = hint.grace_active === true;
+    this.localNovelNames.clear();
+  }
+  /**
+   * Decide whether a `track()` call should proceed.
+   *
+   * Returns true  = send to network (rate-limiter still runs after).
+   * Returns false = drop locally; caller should return early.
+   */
+  shouldSend(eventName) {
+    if (!this.bloom) return true;
+    if (this.graceActive) return true;
+    if (this.bloom.has(eventName)) return true;
+    if (this.localNovelNames.has(eventName)) return true;
+    if (this.remainingNewNames > 0) {
+      this.localNovelNames.add(eventName);
+      this.remainingNewNames -= 1;
+      return true;
+    }
+    const prev = this.droppedSinceLastReport.get(eventName) ?? 0;
+    this.droppedSinceLastReport.set(eventName, prev + 1);
+    if (!this.hasWarnedThisSession) {
+      this.hasWarnedThisSession = true;
+      warnOncePerSession(
+        `[aegis] Event-name cap reached — "${eventName}" dropped locally. Upgrade your plan or remove dynamically-generated event names.`
+      );
+    }
+    return false;
+  }
+  /**
+   * Snapshot + reset the dropped-names counter. Called by the telemetry
+   * beacon on batch flush so the gateway gets visibility into client-side
+   * drops for ops dashboards.
+   */
+  drainDropReport() {
+    if (this.droppedSinceLastReport.size === 0) return null;
+    const events = {};
+    let total = 0;
+    for (const [name, count] of this.droppedSinceLastReport) {
+      events[name] = count;
+      total += count;
+    }
+    const since = this.reportWindowStart;
+    this.droppedSinceLastReport.clear();
+    this.reportWindowStart = Date.now();
+    return { events, total, since };
+  }
+  // Test-only accessors — not part of public API but easier than reflection.
+  /** @internal */
+  _debugState() {
+    return {
+      hasBloom: this.bloom !== null,
+      remaining: this.remainingNewNames,
+      localNovel: this.localNovelNames.size,
+      graceActive: this.graceActive
+    };
+  }
+}
+const RESERVED_PREFIXES = [
+  "system.",
+  "user.",
+  "loyalty.",
+  "review.",
+  "cart.",
+  "checkout.",
+  "product.",
+  "pos.",
+  "bill.",
+  "feedback.",
+  "chat.",
+  "delivery.",
+  "event.",
+  "$",
+  "_"
+];
+const KEY_SOFT_VALUE_CAP = 512;
+const KEY_HARD_VALUE_CAP = 1e4;
+const CAMEL_BOUNDARY_1 = /(.)([A-Z][a-z]+)/g;
+const CAMEL_BOUNDARY_2 = /([a-z0-9])([A-Z])/g;
+const NON_SNAKE = /[\s\-.]+/g;
+const DUPE_UNDERSCORE = /_+/g;
+const ISO_8601 = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?)?$/;
+const DATE_KEY_HINTS = /* @__PURE__ */ new Set([
+  "at",
+  "on",
+  "date",
+  "time",
+  "timestamp",
+  "dob",
+  "birthday",
+  "joined",
+  "expired",
+  "expires",
+  "created",
+  "updated",
+  "started",
+  "ended"
+]);
+function normalizeKey(key) {
+  if (!key) return null;
+  const stage1 = key.replace(CAMEL_BOUNDARY_1, "$1_$2").replace(CAMEL_BOUNDARY_2, "$1_$2");
+  const stage2 = stage1.replace(NON_SNAKE, "_").toLowerCase();
+  const result = stage2.replace(DUPE_UNDERSCORE, "_").replace(/^_+|_+$/g, "");
+  return result || null;
+}
+function startsWithReserved(key) {
+  const lower = key.toLowerCase();
+  for (const prefix of RESERVED_PREFIXES) {
+    if (lower.startsWith(prefix)) return prefix;
+  }
+  return null;
+}
+function looksLikeDateKey(key) {
+  for (const part of key.toLowerCase().split(/[_\-.\s]+/)) {
+    if (DATE_KEY_HINTS.has(part)) return true;
+  }
+  return false;
+}
+function parseDateValue(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value < 1e11 ? Math.floor(value * 1e3) : Math.floor(value);
+  }
+  if (typeof value === "string" && value) {
+    const s = value.trim();
+    if (ISO_8601.test(s)) {
+      const ms = Date.parse(s);
+      if (!Number.isNaN(ms)) return ms;
+    }
+    const asNum = Number(s);
+    if (Number.isFinite(asNum)) {
+      return asNum < 1e11 ? Math.floor(asNum * 1e3) : Math.floor(asNum);
+    }
+  }
+  return null;
+}
+function warnOnConsole(message) {
+  if (typeof console === "undefined" || typeof console.warn !== "function") return;
+  console.warn(message);
+}
+const _TraitGovernor = class _TraitGovernor {
+  constructor() {
+    this.warnCounts = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Apply all guards to a traits object. Returns the sanitized payload
+   * to send + a list of drops/modifications.
+   *
+   * Pass `workspace_id` so warning rate-limits scope per workspace; an
+   * agency user switching workspaces won't have their warning budget
+   * consumed cross-workspace.
+   */
+  process(traits, workspace_id) {
+    const sanitized = {};
+    const drops = [];
+    if (!traits || typeof traits !== "object") {
+      return { sanitized, drops };
+    }
+    for (const rawKey of Object.keys(traits)) {
+      const prefix = startsWithReserved(rawKey);
+      if (prefix !== null) {
+        drops.push({
+          originalKey: rawKey,
+          verdict: "reserved_prefix",
+          reason: `key uses reserved namespace ${JSON.stringify(prefix)}`
+        });
+        continue;
+      }
+      const normalizedKey = normalizeKey(rawKey);
+      if (normalizedKey === null) {
+        drops.push({
+          originalKey: rawKey,
+          verdict: "bad_key_format",
+          reason: `key reduced to empty after normalization`
+        });
+        continue;
+      }
+      if (startsWithReserved(normalizedKey) !== null) {
+        drops.push({
+          originalKey: rawKey,
+          verdict: "reserved_prefix",
+          reason: `normalized key ${JSON.stringify(normalizedKey)} still uses a reserved namespace`
+        });
+        continue;
+      }
+      let value = traits[rawKey];
+      if (typeof value === "string") {
+        if (value.length > KEY_HARD_VALUE_CAP) {
+          drops.push({
+            originalKey: rawKey,
+            verdict: "value_too_long",
+            reason: `value length ${value.length} exceeds hard cap ${KEY_HARD_VALUE_CAP}`
+          });
+          continue;
+        }
+        if (value.length > KEY_SOFT_VALUE_CAP) {
+          drops.push({
+            originalKey: rawKey,
+            verdict: "value_too_long",
+            reason: `value truncated from ${value.length} to ${KEY_SOFT_VALUE_CAP} chars`
+          });
+          value = value.slice(0, KEY_SOFT_VALUE_CAP);
+        }
+      }
+      if (looksLikeDateKey(normalizedKey) && typeof value === "string") {
+        const parsed = parseDateValue(value);
+        if (parsed === null) {
+          drops.push({
+            originalKey: rawKey,
+            verdict: "bad_date_format",
+            reason: `value ${JSON.stringify(value)} on date-keyed field ${JSON.stringify(normalizedKey)} didn't parse as ISO-8601 / epoch`
+          });
+          continue;
+        }
+        value = parsed;
+      }
+      sanitized[normalizedKey] = value;
+    }
+    for (const drop of drops) {
+      this.maybeWarn(workspace_id ?? null, drop);
+    }
+    return { sanitized, drops };
+  }
+  maybeWarn(workspace_id, drop) {
+    const ws = workspace_id ?? "__no_workspace__";
+    let perVerdict = this.warnCounts.get(ws);
+    if (!perVerdict) {
+      perVerdict = /* @__PURE__ */ new Map();
+      this.warnCounts.set(ws, perVerdict);
+    }
+    const count = perVerdict.get(drop.verdict) ?? 0;
+    if (count >= _TraitGovernor.WARN_CAP) return;
+    perVerdict.set(drop.verdict, count + 1);
+    warnOnConsole(
+      `[Active Reach SDK] trait ${drop.verdict}: ${drop.reason} (original key: ${JSON.stringify(drop.originalKey)}). Backend will reject; fix the SDK call to silence this warning.`
+    );
+  }
+};
+_TraitGovernor.WARN_CAP = 3;
+let TraitGovernor = _TraitGovernor;
+const VALID_CHANNELS = /* @__PURE__ */ new Set([
+  "email",
+  "sms",
+  "push",
+  "webpush",
+  "whatsapp",
+  "rcs",
+  "inapp"
+]);
+const EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const PHONE_RE = /^\+[1-9]\d{7,14}$/;
+const SHA256_HEX_RE = /^[a-f0-9]{64}$/i;
+const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+class UserNamespace {
+  constructor(aegis) {
+    this.pendingTraits = {};
+    this.aegis = aegis;
+  }
+  /**
+   * Authoritative identity write. Flushes any pending pre-login traits
+   * along with the supplied `traits` argument as a single identify call.
+   */
+  login(userId, traits) {
+    if (typeof userId !== "string" || userId.length === 0) {
+      logger.warn("[user.login] userId must be a non-empty string");
+      return;
+    }
+    const merged = { ...this.pendingTraits, ...traits || {} };
+    this.pendingTraits = {};
+    this.aegis.identify(userId, merged);
+  }
+  /**
+   * Drops the current userId and any pending pre-login traits. Does NOT
+   * fire a server-side logout event — that's a separate explicit `track`.
+   */
+  logout() {
+    this.pendingTraits = {};
+    this.aegis.reset();
+  }
+  setAttribute(key, value) {
+    if (typeof key !== "string" || key.length === 0) {
+      logger.warn("[user.setAttribute] key must be a non-empty string");
+      return;
+    }
+    this.writeTraits({ [key]: value });
+  }
+  setAttributes(map) {
+    if (!map || typeof map !== "object") {
+      logger.warn("[user.setAttributes] map must be an object");
+      return;
+    }
+    this.writeTraits(map);
+  }
+  setEmail(email) {
+    if (!EMAIL_RE.test(email)) {
+      logger.warn("[user.setEmail] invalid email format");
+      return;
+    }
+    this.writeTraits({ email: email.toLowerCase() });
+  }
+  setPhone(phone) {
+    if (!PHONE_RE.test(phone)) {
+      logger.warn("[user.setPhone] phone must be E.164 (e.g. +15551234567)");
+      return;
+    }
+    this.writeTraits({ phone });
+  }
+  setHashedEmail(sha256Hex) {
+    if (!SHA256_HEX_RE.test(sha256Hex)) {
+      logger.warn("[user.setHashedEmail] expected 64-char hex SHA-256");
+      return;
+    }
+    this.writeTraits({ email_sha256: sha256Hex.toLowerCase() });
+  }
+  setHashedPhone(sha256Hex) {
+    if (!SHA256_HEX_RE.test(sha256Hex)) {
+      logger.warn("[user.setHashedPhone] expected 64-char hex SHA-256");
+      return;
+    }
+    this.writeTraits({ phone_sha256: sha256Hex.toLowerCase() });
+  }
+  setBirthDate(iso) {
+    if (!ISO_DATE_RE.test(iso)) {
+      logger.warn("[user.setBirthDate] expected YYYY-MM-DD");
+      return;
+    }
+    this.writeTraits({ birth_date: iso });
+  }
+  setOptIn(channel, granted) {
+    if (!VALID_CHANNELS.has(channel)) {
+      logger.warn(`[user.setOptIn] unknown channel: ${channel}`);
+      return;
+    }
+    if (typeof granted !== "boolean") {
+      logger.warn("[user.setOptIn] granted must be a boolean");
+      return;
+    }
+    this.writeTraits({ [`opt_in_${channel}`]: granted });
+  }
+  /**
+   * HMAC-signed identity token. Ingress-side verification not yet wired —
+   * the trait is forwarded as-is and persisted on the contact record
+   * until that lands.
+   */
+  setSecureToken(token) {
+    if (typeof token !== "string" || token.length === 0) {
+      logger.warn("[user.setSecureToken] token must be a non-empty string");
+      return;
+    }
+    this.writeTraits({ _secure_token: token });
+  }
+  /**
+   * Test/inspection hook — returns a copy of the pending traits buffer.
+   * Used by the e2e smoke test to assert pre-login accumulation.
+   */
+  _getPendingTraits() {
+    return { ...this.pendingTraits };
+  }
+  // ---------------------------------------------------------------------------
+  writeTraits(traits) {
+    const userId = this.aegis.getUserId();
+    if (userId) {
+      this.aegis.identify(userId, traits);
+      return;
+    }
+    Object.assign(this.pendingTraits, traits);
+  }
+}
+class Aegis {
+  constructor() {
+    this.config = null;
+    this.session = null;
+    this.queue = null;
+    this.transport = null;
+    this.plugins = new PluginRegistry();
+    this.initPromise = null;
+    this.consent = null;
+    this._ecommerce = null;
+    this._user = null;
+    this.rateLimiter = null;
+    this.nameGovernor = new NameGovernor();
+    this.traitGovernor = new TraitGovernor();
+    this._lastPageUrl = null;
+    this._popstateHandler = null;
+    this._originalPushState = null;
+    this._originalReplaceState = null;
+    this._lastEventIds = /* @__PURE__ */ new Map();
+    this._workspaceCodes = /* @__PURE__ */ new Set();
+    this._runtimeWorkspace = null;
+    this._runtimeLocation = null;
+  }
+  async init(writeKey, config) {
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+    this.initPromise = this._init(writeKey, config);
+    return this.initPromise;
+  }
+  async _init(writeKey, config) {
+    var _a;
+    if ((_a = this.config) == null ? void 0 : _a.initialized) {
+      logger.warn("SDK already initialized");
+      return;
+    }
+    if (this.shouldRespectDNT(config)) {
+      logger.info("Do Not Track is enabled, SDK disabled");
+      return;
+    }
+    if (isBot()) {
+      logger.info("Bot detected, SDK disabled");
+      return;
+    }
+    this.config = this.buildConfig(writeKey, config);
+    if (this.config.debug) {
+      logger.enable();
+    }
+    logger.info("Initializing Active Reach SDK...", this.config);
+    this.storage = new Storage({
+      cookieDomain: this.config.cookie_domain,
+      secureCookie: this.config.secure_cookie,
+      crossDomain: this.config.cross_domain_tracking
+    });
+    this.identity = new Identity(this.storage);
+    this.consent = new ConsentManager(this.storage, {
+      defaultConsent: this.config.default_consent,
+      waitForConsent: this.config.wait_for_consent
+    });
+    if (this.config.integrate_onetrust) {
+      this.consent.integrateOneTrust();
+    }
+    if (this.config.integrate_cookiebot) {
+      this.consent.integrateCookiebot();
+    }
+    if (this.config.integrate_google_consent_mode) {
+      this.consent.integrateGoogleConsentMode();
+    }
+    this.session = new SessionManager(
+      this.storage,
+      this.config.session_timeout
+    );
+    this.captureAdClickIDsOnInit();
+    this.transport = new Transport(
+      {
+        writeKey: this.config.write_key,
+        apiHost: this.config.api_host,
+        cellEndpoints: this.config.cell_endpoints,
+        preferredRegion: this.config.preferred_region,
+        autoRegionDetection: this.config.auto_region_detection,
+        requestTimeout: this.config.request_timeout,
+        retryFailedRequests: this.config.retry_failed_requests,
+        maxRetries: this.config.max_retries,
+        retryBackoffMultiplier: this.config.retry_backoff_multiplier
+      },
+      this.storage
+    );
+    this.config.active_cell = this.transport.getActiveCell();
+    this.queue = new EventQueue(
+      {
+        batchSize: this.config.batch_size,
+        batchInterval: this.config.batch_interval,
+        enableOfflineMode: this.config.enable_offline_mode,
+        maxOfflineEvents: this.config.max_offline_events
+      },
+      this.transport,
+      this.storage
+    );
+    this.rateLimiter = new RateLimiter({
+      burstCapacity: this.config.rate_limit_burst,
+      refillPerSecond: this.config.rate_limit_per_second,
+      onDropBatch: (count, sampleName) => this.emitRateLimitMeta(count, sampleName)
+    });
+    await this.initializePlugins();
+    if (this.config.auto_page_view) {
+      this.page();
+      this.startSPATracking();
+    }
+    logger.info("Active Reach SDK initialized successfully");
+  }
+  /**
+   * SPA navigation tracking — monkey-patches pushState/replaceState and
+   * listens for popstate to fire page() on every client-side route change.
+   */
+  startSPATracking() {
+    this._lastPageUrl = window.location.href;
+    const onRouteChange = () => {
+      const currentUrl = window.location.href;
+      if (currentUrl === this._lastPageUrl) return;
+      this._lastPageUrl = currentUrl;
+      setTimeout(() => {
+        if (!this._popstateHandler) return;
+        this.page();
+      }, 50);
+    };
+    this._popstateHandler = onRouteChange;
+    window.addEventListener("popstate", this._popstateHandler);
+    this._originalPushState = history.pushState.bind(history);
+    this._originalReplaceState = history.replaceState.bind(history);
+    history.pushState = (...args) => {
+      this._originalPushState(...args);
+      onRouteChange();
+    };
+    history.replaceState = (...args) => {
+      this._originalReplaceState(...args);
+      onRouteChange();
+    };
+  }
+  stopSPATracking() {
+    if (this._popstateHandler) {
+      window.removeEventListener("popstate", this._popstateHandler);
+      this._popstateHandler = null;
+    }
+    if (this._originalPushState) {
+      history.pushState = this._originalPushState;
+      this._originalPushState = null;
+    }
+    if (this._originalReplaceState) {
+      history.replaceState = this._originalReplaceState;
+      this._originalReplaceState = null;
+    }
+  }
+  buildConfig(writeKey, config) {
+    return {
+      ...DEFAULT_CONFIG,
+      ...config,
+      write_key: writeKey,
+      initialized: true
+    };
+  }
+  shouldRespectDNT(config) {
+    const respectDNT = (config == null ? void 0 : config.respect_dnt) !== false;
+    if (!respectDNT) return false;
+    const dnt = navigator.doNotTrack || window.doNotTrack || navigator.msDoNotTrack;
+    return dnt === "1" || dnt === "yes";
+  }
+  captureAdClickIDsOnInit() {
+    if (!this.session) return;
+    const adClickIDs = parseAdClickIDs();
+    if (hasAdClickIDs(adClickIDs)) {
+      this.session.setAdClickIDs(adClickIDs, redactUrl(window.location.href));
+      logger.info("Ad click IDs captured on page load:", adClickIDs);
+    }
+    const linkAttribution = parseLinkAttribution();
+    if (linkAttribution.aegis_code) {
+      this.session.setLinkAttribution(linkAttribution);
+    }
+  }
+  async initializePlugins() {
+    if (!this.config) return;
+    for (const pluginName of this.config.plugins) {
+      logger.debug(`Initializing plugin: ${pluginName}`);
+    }
+    await this.plugins.executeHook("init", this.config);
+  }
+  use(plugin) {
+    var _a;
+    this.plugins.register(plugin);
+    if (((_a = this.config) == null ? void 0 : _a.initialized) && plugin.init) {
+      Promise.resolve(plugin.init(this.config)).catch((error) => {
+        logger.error(`Failed to initialize plugin "${plugin.name}":`, error);
+      });
+    }
+  }
+  /**
+   * Symmetric counterpart to `use(plugin)`. Calls the plugin's `destroy()`
+   * hook (if defined) and removes it from the registry so its hooks no
+   * longer fire on subsequent events. Safe to call with a name that
+   * isn't registered — logs a warning and returns.
+   *
+   * Primary use case: React components that register a plugin in
+   * `useEffect` and need to unregister in the cleanup function so HMR /
+   * provider remount doesn't leak listeners. See cashier-portal's
+   * MetaPixelInjector for an example.
+   */
+  removePlugin(name) {
+    this.plugins.unregister(name);
+  }
+  /**
+   * Plugin-handshake P1 — ingest the workspace_code allowlist from the
+   * bootstrap response. Pass `result.workspaceCodes` from `bootstrap()`
+   * here so the SDK can do path-segment workspace detection on
+   * customer-facing pages like `/south/rewards`, `/ghatkopar/feedback`.
+   *
+   * Empty array is the right answer for single-outlet tenants — SDK
+   * will skip the path cascade and fall through to query param /
+   * setWorkspace() / gateway origin lookup.
+   *
+   * Safe to call before init() — the set is consulted at event-fire time.
+   */
+  ingestWorkspaceCodes(codes) {
+    this._workspaceCodes = new Set(
+      (codes ?? []).filter((c) => typeof c === "string" && c.length > 0)
+    );
+    logger.debug("Workspace codes ingested", { count: this._workspaceCodes.size });
+  }
+  /**
+   * Plugin-handshake P1 (Track E) — explicitly set the workspace for
+   * subsequent events. Used by:
+   *   - SPAs where workspace context changes via in-app routing
+   *   - Mobile / RN apps that have no URL
+   *   - Custom integrations that resolve workspace from their own state
+   *
+   * Pass null to clear (or call clearWorkspace()).
+   *
+   * Persisted to sessionStorage so SPA reloads / page transitions on the
+   * same outlet inherit it without re-calling.
+   */
+  setWorkspace(codeOrId) {
+    this._runtimeWorkspace = codeOrId;
+    if (typeof window !== "undefined" && window.sessionStorage) {
+      try {
+        if (codeOrId) {
+          window.sessionStorage.setItem("aegis_runtime_ws", codeOrId);
+        } else {
+          window.sessionStorage.removeItem("aegis_runtime_ws");
+        }
+      } catch {
+      }
+    }
+    logger.debug("Runtime workspace set", { value: codeOrId });
+  }
+  /** Symmetric helper to clear the runtime workspace. */
+  clearWorkspace() {
+    this.setWorkspace(null);
+  }
+  // ── P15.1 — location (outlet) facade ─────────────────────────
+  //
+  // Under the post-2026-05-26 canonical hierarchy:
+  //   workspace_id = brand-tenant (one per brand)
+  //   location_id  = outlet within a brand
+  // The two are distinct dimensions. Both can be stamped on the
+  // same event. These methods mirror the workspace facade but
+  // resolve the outlet specifically.
+  /**
+   * P15.1 — ingest the outlet-code allowlist from bootstrap. The
+   * SDK consults this set when reading the URL path segment to
+   * decide whether `location.pathname.split('/')[1]` is a valid
+   * outlet code vs a generic route.
+   *
+   * Empty array = single-outlet tenant; SDK skips the path-segment
+   * cascade for location resolution.
+   *
+   * Safe to call before init(); the set is consulted at event-
+   * fire time.
+   */
+  ingestLocationCodes(codes) {
+    this._workspaceCodes = new Set(
+      (codes ?? []).filter((c) => typeof c === "string" && c.length > 0)
+    );
+    logger.debug("Location codes ingested", { count: this._workspaceCodes.size });
+  }
+  /**
+   * P15.1 — explicitly set the active outlet for subsequent events.
+   * Used by:
+   *   - Storefronts where outlet picker fires `aegis.setLocation()`
+   *     on selection (so events that follow carry that outlet's
+   *     location_id without the SDK having to re-parse the URL).
+   *   - SPAs where outlet context changes via in-app routing.
+   *   - Mobile/RN apps that have no URL.
+   *
+   * Pass null to clear (or call clearLocation()).
+   *
+   * Persisted to sessionStorage so SPA reloads + route transitions
+   * on the same outlet inherit it without re-calling.
+   */
+  setLocation(codeOrId) {
+    this._runtimeLocation = codeOrId;
+    if (typeof window !== "undefined" && window.sessionStorage) {
+      try {
+        if (codeOrId) {
+          window.sessionStorage.setItem("aegis_runtime_location", codeOrId);
+        } else {
+          window.sessionStorage.removeItem("aegis_runtime_location");
+        }
+      } catch {
+      }
+    }
+    logger.debug("Runtime location set", { value: codeOrId });
+  }
+  /** Symmetric helper to clear the runtime location. */
+  clearLocation() {
+    this.setLocation(null);
+  }
+  /**
+   * P15.1 — same logic as `getPathWorkspaceCode()` but expresses
+   * the semantic correctly: under the new hierarchy, the first
+   * path segment after the brand subdomain IS the outlet code.
+   * Returns `undefined` when no outlet code matches the allowlist.
+   */
+  getPathLocationCode() {
+    return this.getPathWorkspaceCode();
+  }
+  /**
+   * P15.1 — resolve the effective `location_id` for the next event.
+   * Independent of `getEffectiveWorkspaceId()`: both run on every
+   * event so workspace_id (brand) and location_id (outlet) land
+   * on the same event when both are resolvable.
+   *
+   * Cascade (highest precedence first):
+   *   1. `this.config.location_id` — explicit operator config.
+   *   2. `?location=` query param (also accepts `?ws=` for back-
+   *      compat with storefronts that pass outlet via the old
+   *      param name — the value is the same; param naming only).
+   *   3. URL path segment matching the outlet-code allowlist.
+   *   4. Runtime `aegis.setLocation()` (in-memory).
+   *   5. sessionStorage `aegis_runtime_location`.
+   *   6. `undefined` — event-ingress treats as brand-tier
+   *      (no outlet attribution).
+   */
+  getEffectiveLocationId() {
+    var _a;
+    const configured = (_a = this.config) == null ? void 0 : _a.location_id;
+    if (configured) return configured;
+    if (typeof window === "undefined") return void 0;
+    try {
+      const search = new URLSearchParams(window.location.search);
+      const loc = search.get("location") || search.get("ws");
+      if (loc && loc.length > 0) return loc;
+    } catch {
+    }
+    const pathLoc = this.getPathLocationCode();
+    if (pathLoc) return pathLoc;
+    if (this._runtimeLocation) return this._runtimeLocation;
+    try {
+      if (window.sessionStorage) {
+        const cached = window.sessionStorage.getItem("aegis_runtime_location");
+        if (cached && cached.length > 0) return cached;
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  /**
+   * Inspect the URL's first path segment and return it if it's in the
+   * org's workspace_code allowlist. Skips well-known non-workspace prefixes
+   * (e.g. `b` for bill short codes; `s` is the storefront app slug).
+   *
+   * Returns undefined when:
+   *   - window is undefined (SSR / Node)
+   *   - path is empty / root
+   *   - first segment isn't in `_workspaceCodes` (e.g. /products, /cart)
+   *
+   * The returned value is a workspace CODE (slug like "south"), not a
+   * UUID. The gateway normalizes code → UUID server-side via
+   * workspace_subaccounts lookup with Redis cache.
+   */
+  getPathWorkspaceCode() {
+    if (typeof window === "undefined") return void 0;
+    if (this._workspaceCodes.size === 0) return void 0;
+    try {
+      const segments = window.location.pathname.split("/").filter(Boolean);
+      if (segments.length === 0) return void 0;
+      const first = segments[0].toLowerCase();
+      return this._workspaceCodes.has(first) ? first : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Resolve the effective `workspace_id` for the next event.
+   *
+   * Cascade (highest precedence first):
+   *   1. `this.config.workspace_id` — explicit operator config (headless
+   *      SDK usage, server-rendered apps, native shells).
+   *   2. `?ws=` query param on the current URL — the P3 storefront URL
+   *      contract. The outlet picker writes this via `router.replace`.
+   *   3. URL path segment (P1 Track A) — `/south/rewards` → "south" when
+   *      "south" is in the org's workspace_code allowlist.
+   *   4. `aegis.setWorkspace()` runtime override (P1 Track E) — SPAs +
+   *      mobile + custom integrations.
+   *   5. sessionStorage `aegis_runtime_ws` — persists setWorkspace across
+   *      reloads/SPA route changes.
+   *   6. `undefined` — gateway falls back to `resolveByOrigin` lookup
+   *      against the property's allowed_origins.
+   *
+   * The returned value can be EITHER a UUID (from config / ?ws=) or a
+   * workspace CODE slug (from path / setWorkspace). The gateway
+   * normalizes slug → UUID server-side; analytics layer never needs to
+   * worry about the difference.
+   *
+   * See docs/architecture/MULTI_OUTLET_URL_STRATEGY.md §2.3 and
+   * docs/architecture/PLUGIN_HANDSHAKE_AUTOMATION.md §2.
+   */
+  /**
+   * Public so peer SDK surfaces (AegisMessageRuntime / AegisInAppManager /
+   * AegisWidgetManager) can plumb the same
+   * resolved workspace into their own gateway POSTs. Each manager calls
+   * the gateway on its own endpoint (`/v1/in-app/events`,
+   * `/v1/widgets/track-event`); without this,
+   * those events arrive at event-ingress with no workspace_id stamped
+   * → impressions/clicks fall back to the org's primary workspace and
+   * cross-outlet attribution breaks.
+   */
+  getEffectiveWorkspaceId() {
+    var _a;
+    const configured = (_a = this.config) == null ? void 0 : _a.workspace_id;
+    if (configured) return configured;
+    if (typeof window === "undefined") return void 0;
+    try {
+      const ws = new URLSearchParams(window.location.search).get("ws");
+      if (ws && ws.length > 0) return ws;
+    } catch {
+    }
+    const pathWs = this.getPathWorkspaceCode();
+    if (pathWs) return pathWs;
+    if (this._runtimeWorkspace) return this._runtimeWorkspace;
+    try {
+      if (window.sessionStorage) {
+        const cached = window.sessionStorage.getItem("aegis_runtime_ws");
+        if (cached && cached.length > 0) return cached;
+      }
+    } catch {
+    }
+    return void 0;
+  }
+  track(eventName, properties) {
+    if (!this.assertInitialized()) return;
+    const messageId = generateMessageId();
+    const event = {
+      type: "track",
+      event: eventName,
+      properties: properties || {},
+      messageId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      anonymousId: this.identity.getAnonymousId(),
+      userId: this.identity.getUserId() || void 0,
+      sessionId: this.session.getSessionId(),
+      workspace_id: this.getEffectiveWorkspaceId(),
+      location_id: this.getEffectiveLocationId(),
+      context: buildContext(this.config, this.session)
+    };
+    this._lastEventIds.set(eventName, messageId);
+    this.captureEvent(event);
+  }
+  identify(userId, traits) {
+    if (!this.assertInitialized()) return;
+    const wsForGovernor = this.getEffectiveWorkspaceId() || null;
+    const { sanitized: governedTraits } = this.traitGovernor.process(traits, wsForGovernor);
+    if (this.identity.getUserId() !== userId) {
+      this.contactToken = void 0;
+    }
+    this.identity.setUserId(userId, governedTraits);
+    const event = {
+      type: "identify",
+      traits: governedTraits,
+      messageId: generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      anonymousId: this.identity.getAnonymousId(),
+      userId,
+      sessionId: this.session.getSessionId(),
+      workspace_id: this.getEffectiveWorkspaceId(),
+      location_id: this.getEffectiveLocationId(),
+      context: buildContext(this.config, this.session)
+    };
+    this.captureEvent(event);
+  }
+  page(name, properties) {
+    if (!this.assertInitialized()) return;
+    const event = {
+      type: "page",
+      name: name || document.title,
+      properties: properties || {},
+      messageId: generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      anonymousId: this.identity.getAnonymousId(),
+      userId: this.identity.getUserId() || void 0,
+      sessionId: this.session.getSessionId(),
+      workspace_id: this.getEffectiveWorkspaceId(),
+      location_id: this.getEffectiveLocationId(),
+      context: buildContext(this.config, this.session)
+    };
+    this.captureEvent(event);
+  }
+  group(groupId, traits) {
+    if (!this.assertInitialized()) return;
+    const wsForGovernor = this.getEffectiveWorkspaceId() || null;
+    const { sanitized: governedTraits } = this.traitGovernor.process(traits, wsForGovernor);
+    const event = {
+      type: "group",
+      groupId,
+      traits: governedTraits,
+      messageId: generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      anonymousId: this.identity.getAnonymousId(),
+      userId: this.identity.getUserId() || void 0,
+      sessionId: this.session.getSessionId(),
+      context: buildContext(this.config, this.session)
+    };
+    this.captureEvent(event);
+  }
+  alias(newUserId) {
+    if (!this.assertInitialized()) return;
+    const { previousId } = this.identity.alias(newUserId);
+    const event = {
+      type: "alias",
+      previousId,
+      messageId: generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      anonymousId: this.identity.getAnonymousId(),
+      userId: newUserId,
+      sessionId: this.session.getSessionId(),
+      context: buildContext(this.config, this.session)
+    };
+    this.captureEvent(event);
+  }
+  /**
+   * SPA-logical screen view. Distinct from `page()` (URL-bound) — fires
+   * when the user enters a logical surface like cart / checkout / drawer
+   * without a URL change. Gateway maps `screen` → `engagement.screen_view`.
+   */
+  screen(name, properties) {
+    if (!this.assertInitialized()) return;
+    if (typeof name !== "string" || name.length === 0) {
+      logger.warn("aegis.screen: name must be a non-empty string");
+      return;
+    }
+    const event = {
+      type: "screen",
+      name,
+      properties: properties || {},
+      messageId: generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      anonymousId: this.identity.getAnonymousId(),
+      userId: this.identity.getUserId() || void 0,
+      sessionId: this.session.getSessionId(),
+      workspace_id: this.getEffectiveWorkspaceId(),
+      location_id: this.getEffectiveLocationId(),
+      context: buildContext(this.config, this.session)
+    };
+    this.captureEvent(event);
+  }
+  async captureEvent(event) {
+    var _a;
+    if (((_a = this.config) == null ? void 0 : _a.enable_consent_mode) && this.consent) {
+      if (event.type === "track" || event.type === "page") {
+        if (!this.consent.hasConsent("analytics")) {
+          logger.debug("Event blocked: analytics consent not granted");
+          return;
+        }
+      }
+    }
+    if (event.type === "track") {
+      const trackEvent = event;
+      const isMetaEvent = typeof trackEvent.event === "string" && trackEvent.event.startsWith("aegis.client.");
+      if (!isMetaEvent && !this.nameGovernor.shouldSend(trackEvent.event)) {
+        return;
+      }
+    }
+    if (this.rateLimiter) {
+      const eventLabel = event.type === "track" && event.event ? event.event : event.type;
+      const isMetaEvent = event.type === "track" && typeof event.event === "string" && event.event.startsWith("aegis.client.");
+      if (!isMetaEvent && !this.rateLimiter.tryConsume(eventLabel)) {
+        return;
+      }
+    }
+    const ctx = event.context;
+    const props = event.properties;
+    if ((ctx == null ? void 0 : ctx.campaign) && props) {
+      const utm = ctx.campaign;
+      if (utm.source && !props.utm_source) props.utm_source = utm.source;
+      if (utm.medium && !props.utm_medium) props.utm_medium = utm.medium;
+      if (utm.campaign && !props.utm_campaign) props.utm_campaign = utm.campaign;
+      if (utm.content && !props.utm_content) props.utm_content = utm.content;
+      if (utm.term && !props.utm_term) props.utm_term = utm.term;
+    }
+    if ((ctx == null ? void 0 : ctx.adClickIDs) && props) {
+      const clicks = ctx.adClickIDs;
+      if (clicks.gclid && !props.gclid) props.gclid = clicks.gclid;
+      if (clicks.gbraid && !props.gbraid) props.gbraid = clicks.gbraid;
+      if (clicks.wbraid && !props.wbraid) props.wbraid = clicks.wbraid;
+      if (clicks.fbclid && !props.fbclid) props.fbclid = clicks.fbclid;
+      const clickId = clicks.gclid || clicks.fbclid || clicks.ctwa_clid || clicks.msclkid || clicks.ttclid;
+      if (clickId && !props.campaign_click_id) props.campaign_click_id = clickId;
+    }
+    if (props && this.session) {
+      const link = this.session.getLinkAttribution();
+      if (link.aegis_code) {
+        for (const [key, value] of Object.entries(link)) {
+          if (value && !props[key]) props[key] = value;
+        }
+      }
+    }
+    if (props) {
+      const meta = captureMetaCookies();
+      if (meta.fbp && !props.fbp) props.fbp = meta.fbp;
+      if (meta.fbc && !props.fbc) props.fbc = meta.fbc;
+      if (meta.fbclid && !props.fbclid) props.fbclid = meta.fbclid;
+    }
+    logger.debug("Capturing event:", redactMetaCookies(event));
+    const transformedEvent = await this.plugins.executeHookChain(
+      "beforeEventCapture",
+      event
+    );
+    if (!transformedEvent) {
+      logger.debug("Event cancelled by plugin");
+      return;
+    }
+    this.queue.push(transformedEvent);
+    this.session.incrementEventCount();
+    await this.plugins.executeHook("afterEventCapture", transformedEvent);
+  }
+  /**
+   * Emit a coalesced meta-event reporting client-side rate-limit drops.
+   * Bypasses the limiter (see captureEvent guard).
+   */
+  emitRateLimitMeta(count, sampleEventName) {
+    var _a, _b;
+    if (!((_a = this.config) == null ? void 0 : _a.initialized) || !this.session || !this.identity) return;
+    const event = {
+      type: "track",
+      event: "aegis.client.rate_limited",
+      properties: {
+        dropped_count: count,
+        sample_event_name: sampleEventName,
+        burst_capacity: this.config.rate_limit_burst,
+        refill_per_second: this.config.rate_limit_per_second
+      },
+      messageId: generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      anonymousId: this.identity.getAnonymousId(),
+      userId: this.identity.getUserId() || void 0,
+      sessionId: this.session.getSessionId(),
+      context: buildContext(this.config, this.session)
+    };
+    (_b = this.queue) == null ? void 0 : _b.push(event);
+  }
+  reset() {
+    if (!this.assertInitialized()) return;
+    this.identity.reset();
+    this._user = null;
+    logger.info("User identity reset");
+  }
+  /**
+   * Ingest the event-governance hint returned from `/v1/sdk/bootstrap`.
+   *
+   * Callers (Shopify pixel, snippet, react integration) run `bootstrap()`
+   * themselves and pass the resulting `eventGovernance` field here so the
+   * SDK can self-throttle novel event names before they hit the gateway.
+   *
+   * Passing null/undefined disables governance (Enterprise plan / outage
+   * fail-open). Safe to call before `init()` — the hint is stored and
+   * applied as soon as init completes.
+   */
+  ingestGovernanceHint(hint) {
+    this.nameGovernor.ingestHint(hint ?? null);
+    logger.debug("Governance hint ingested", hint ? {
+      k: hint.k,
+      m: hint.m,
+      remaining: hint.remaining_new_names
+    } : "disabled");
+  }
+  /**
+   * Drain the client-side drop counter and emit a meta-event. Called
+   * periodically by the queue flush path so ops dashboards see novel-name
+   * amplification patterns in near-real-time.
+   */
+  emitGovernanceDropMeta() {
+    var _a, _b;
+    if (!((_a = this.config) == null ? void 0 : _a.initialized) || !this.session || !this.identity) return;
+    const report = this.nameGovernor.drainDropReport();
+    if (!report) return;
+    const event = {
+      type: "track",
+      event: "aegis.client.name_governor_dropped",
+      properties: {
+        dropped_count: report.total,
+        distinct_names: Object.keys(report.events).length,
+        // Cap the payload — a runaway loop could produce thousands of names;
+        // we ship the top 10 for diagnostics and the total for counting.
+        sample_names: Object.entries(report.events).sort((a, b) => b[1] - a[1]).slice(0, 10).map(([name, count]) => ({ name, count })),
+        window_start: report.since,
+        window_end: Date.now()
+      },
+      messageId: generateMessageId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      anonymousId: this.identity.getAnonymousId(),
+      userId: this.identity.getUserId() || void 0,
+      sessionId: this.session.getSessionId(),
+      context: buildContext(this.config, this.session)
+    };
+    (_b = this.queue) == null ? void 0 : _b.push(event);
+  }
+  async flush() {
+    if (!this.assertInitialized()) return;
+    this.emitGovernanceDropMeta();
+    await this.queue.flush();
+  }
+  getAnonymousId() {
+    if (!this.identity) return null;
+    return this.identity.getAnonymousId();
+  }
+  getUserId() {
+    if (!this.identity) return null;
+    return this.identity.getUserId();
+  }
+  /**
+   * C1b: register the server-minted proof for the CURRENT contact (as
+   * returned by `getUserId()`). A host wiring `AegisMessageRuntime` calls
+   * this alongside `runtime.updateContactId(id, token)` so `getRewards()`
+   * can also present `X-Contact-Token`. Pass `undefined` to clear it (e.g.
+   * on logout, or when the id changes without a fresh token).
+   */
+  setContactToken(token) {
+    this.contactToken = token;
+  }
+  /**
+   * The Aegis short-link attribution captured from this visitor's landing URL
+   * (`aegis_code` + the link row's `aegis_campaign` / `aegis_journey` /
+   * `aegis_playbook` / `aegis_button`), or `{}` when they did not arrive
+   * through one. Hosts forward `aegis_code` with an order so the order can be
+   * joined to the send that brought the shopper. Never contains `utm_*`, `k`,
+   * `t` or `u`.
+   */
+  getLinkAttribution() {
+    if (!this.session) return {};
+    return { ...this.session.getLinkAttribution() };
+  }
+  /**
+   * Fetch the identified contact's REDEEMABLE rewards — coupon codes the
+   * storefront can auto-apply at checkout + loyalty points balance/tier.
+   * Mirrors `GET /api/v1/sdk/entitlements`. Returns `null` when the SDK is
+   * uninitialised, the contact is anonymous, the endpoint returns 204 (nothing
+   * to show), or on any network/HTTP error — callers degrade gracefully.
+   *
+   * Scoped to the identified contact (own grants only) and, when an outlet is
+   * resolvable (`getEffectiveLocationId()`), to org-wide + that outlet's grants.
+   */
+  async getRewards() {
+    const config = this.config;
+    if (!config || !config.api_host || !this.identity) return null;
+    const contactId = this.identity.getUserId();
+    if (!contactId) return null;
+    const apiHost = config.api_host.replace(/\/$/, "");
+    const headers = {
+      "X-Aegis-Write-Key": config.write_key,
+      "X-Contact-ID": contactId,
+      "X-User-ID": contactId
+    };
+    if (this.contactToken) headers["X-Contact-Token"] = this.contactToken;
+    const orgId = config.organization_id;
+    if (orgId) headers["X-Organization-ID"] = orgId;
+    const location = this.getEffectiveLocationId();
+    if (location) headers["X-Location-Id"] = location;
+    try {
+      const resp = await fetch(`${apiHost}/api/v1/sdk/entitlements`, {
+        method: "GET",
+        headers,
+        credentials: "include"
+      });
+      if (resp.status === 204 || !resp.ok) return null;
+      return await resp.json();
+    } catch (err) {
+      logger.warn("getRewards() failed", err);
+      return null;
+    }
+  }
+  getSessionId() {
+    if (!this.session) return null;
+    return this.session.getSessionId();
+  }
+  /**
+   * B1.2 — Tenant-Pixel coexistence handoff. Returns the messageId of the
+   * most recent `track('<eventName>', ...)` call, or null if no event of
+   * that name has been tracked since SDK init.
+   *
+   * Use this from a tenant's own Meta Pixel script (e.g. via GTM) to pass
+   * the same event_id to `fbq('track', '<eventName>', payload, {eventID: id})`.
+   * Meta dedups on (pixel_id, event_name, event_id) so the browser-fired
+   * Pixel event and our server-side CAPI event collapse to one — preventing
+   * double-counting.
+   *
+   * Event names are case-sensitive ("Purchase" ≠ "purchase") — Meta's dedup
+   * is also case-sensitive, so be exact.
+   *
+   * See docs/integrations/META_PIXEL_COEXISTENCE.md.
+   */
+  lastEventId(eventName) {
+    return this._lastEventIds.get(eventName) ?? null;
+  }
+  debug(enable = true) {
+    if (enable) {
+      logger.enable();
+    } else {
+      logger.disable();
+    }
+    if (this.config) {
+      this.config.debug = enable;
+    }
+  }
+  setCell(cellEndpoint) {
+    if (!this.config) {
+      logger.warn("SDK not initialized");
+      return;
+    }
+    const existingCell = this.config.cell_endpoints.find(
+      (c) => c.region === cellEndpoint.region
+    );
+    if (existingCell) {
+      Object.assign(existingCell, cellEndpoint);
+    } else {
+      this.config.cell_endpoints.push(cellEndpoint);
+    }
+    logger.info("Cell endpoint configured:", cellEndpoint);
+  }
+  getCellInfo() {
+    if (!this.transport) return null;
+    return {
+      activeCell: this.transport.getActiveCell(),
+      latencies: this.transport.getRegionLatencies()
+    };
+  }
+  setConsent(preferences) {
+    if (!this.consent) {
+      logger.warn("Consent manager not initialized");
+      return;
+    }
+    this.consent.setConsent(preferences);
+    logger.info("Consent preferences updated");
+  }
+  grantConsent(category) {
+    if (!this.consent) {
+      logger.warn("Consent manager not initialized");
+      return;
+    }
+    if (category) {
+      this.consent.setConsent({ [category]: true });
+    } else {
+      this.consent.grantAll();
+    }
+  }
+  denyConsent(category) {
+    if (!this.consent) {
+      logger.warn("Consent manager not initialized");
+      return;
+    }
+    if (category) {
+      this.consent.setConsent({ [category]: false });
+    } else {
+      this.consent.denyAll();
+    }
+  }
+  hasConsent(category) {
+    if (!this.consent) {
+      return true;
+    }
+    return this.consent.hasConsent(category);
+  }
+  getConsentPreferences() {
+    if (!this.consent) {
+      return null;
+    }
+    return this.consent.getPreferences();
+  }
+  onConsentChange(callback) {
+    if (!this.consent) {
+      logger.warn("Consent manager not initialized");
+      return () => {
+      };
+    }
+    return this.consent.onChange(callback);
+  }
+  assertInitialized() {
+    var _a;
+    if (!((_a = this.config) == null ? void 0 : _a.initialized)) {
+      logger.warn("SDK not initialized. Call aegis.init() first.");
+      return false;
+    }
+    return true;
+  }
+  get ecommerce() {
+    if (!this._ecommerce) {
+      this._ecommerce = new EcommerceTracker(this);
+    }
+    return this._ecommerce;
+  }
+  get user() {
+    if (!this._user) {
+      this._user = new UserNamespace(this);
+    }
+    return this._user;
+  }
+  destroy() {
+    this.stopSPATracking();
+    if (this.queue) {
+      this.queue.destroy();
+    }
+    if (this.session) {
+      this.session.destroy();
+    }
+    if (this.transport) {
+      this.transport.destroy();
+    }
+    if (this.rateLimiter) {
+      this.rateLimiter.destroy();
+      this.rateLimiter = null;
+    }
+    this.plugins.clear();
+    logger.info("SDK destroyed");
+  }
+}
+export {
+  Aegis as A,
+  BloomFilter as B,
+  EcommerceTracker as E,
+  NameGovernor as N,
+  RateLimiter as R,
+  Storage as S,
+  UserNamespace as U,
+  logger as l,
+  murmurhash3_x86_32 as m,
+  redactUrl as r
+};
+//# sourceMappingURL=analytics-C-Go3Pm5.mjs.map