@nexushub/client 0.3.0 → 0.3.2

package/dist/index.cjs

@@ -1315,12 +1315,6 @@ var getVisitorId = async () => {
 };
 
 // src/analytics/vitals.ts
-
-
-
-
-
-
 var _webvitals = require('web-vitals');
 var METRIC_KEY_MAP = {
   CLS: "cls",
@@ -1354,7 +1348,35 @@ var VitalsCollector = class {
         dns_lookup: navEntry.domainLookupEnd - navEntry.domainLookupStart,
         tcp_connect: navEntry.connectEnd - navEntry.connectStart,
         request_time: navEntry.responseEnd - navEntry.requestStart,
-        dom_load: navEntry.domComplete - navEntry.domInteractive
+        dom_load: navEntry.domComplete - navEntry.domInteractive,
+        // NEW: raw fields matching Rust NavigationTiming struct
+        domain_lookup_start: navEntry.domainLookupStart,
+        domain_lookup_end: navEntry.domainLookupEnd,
+        connect_start: navEntry.connectStart,
+        connect_end: navEntry.connectEnd,
+        secure_connection_start: navEntry.secureConnectionStart > 0 ? navEntry.secureConnectionStart : void 0
+      };
+      this.hasUpdates = true;
+    }
+    const resourceEntries = performance.getEntriesByType(
+      "resource"
+    );
+    if (resourceEntries.length > 0) {
+      this.metrics.resources = resourceEntries.filter((r) => !r.name.includes("/api/collect")).sort((a, b) => b.duration - a.duration).slice(0, 20).map((r) => ({
+        name: r.name,
+        initiator_type: r.initiatorType,
+        duration: Math.round(r.duration),
+        transfer_size: r.transferSize > 0 ? r.transferSize : void 0,
+        encoded_body_size: r.encodedBodySize > 0 ? r.encodedBodySize : void 0
+      }));
+      this.hasUpdates = true;
+    }
+    const mem = performance.memory;
+    if (mem) {
+      this.metrics.memory_usage = {
+        used_js_heap_size: mem.usedJSHeapSize,
+        total_js_heap_size: mem.totalJSHeapSize,
+        js_heap_size_limit: mem.jsHeapSizeLimit
       };
       this.hasUpdates = true;
     }
@@ -1362,11 +1384,13 @@ var VitalsCollector = class {
   getMetricsSnapshot() {
     if (!this.hasUpdates) return null;
     this.hasUpdates = false;
-    return { ...this.metrics };
+    const snapshot = { ...this.metrics };
+    this.metrics.resources = void 0;
+    return snapshot;
   }
 };
 var vitalsCollector = new VitalsCollector();
-var initVitals = (tracker) => {
+var initVitals = (_tracker) => {
   if (process.env.NODE_ENV === "development") {
     console.log("[NexusHub] Web Vitals monitoring active");
   }
@@ -1485,10 +1509,41 @@ var EventStorage = class {
 var eventStorage = new EventStorage();
 
 // src/analytics/tracker.ts
+var SDK_VERSION = "0.1.0";
+var safeGetItem = (key) => {
+  try {
+    return localStorage.getItem(key);
+  } catch (e6) {
+    return null;
+  }
+};
+var safeSetItem = (key, value) => {
+  try {
+    localStorage.setItem(key, value);
+  } catch (e7) {
+  }
+};
+var safeRemoveItem = (key) => {
+  try {
+    localStorage.removeItem(key);
+  } catch (e8) {
+  }
+};
+var generateUUID = () => {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    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);
+  });
+};
 var Tracker = class {
   constructor(config) {
     this.sessionId = "";
     this.visitorId = "";
+    this.anonymousId = "";
     this.isFlushing = false;
     this.config = config;
     this.endpoint = `${this.config.analyticsUrl}/api/collect`;
@@ -1501,28 +1556,40 @@ var Tracker = class {
   }
   async initSession() {
     this.visitorId = await getVisitorId();
-    let sid = localStorage.getItem("nexus_sid");
-    const lastActivity = localStorage.getItem("nexus_last_active");
+    let anonId = safeGetItem("nexus_anon_id");
+    if (!anonId) {
+      anonId = `anon_${generateUUID().replace(/-/g, "")}`;
+      safeSetItem("nexus_anon_id", anonId);
+    }
+    this.anonymousId = anonId;
+    let sid = safeGetItem("nexus_sid");
+    const lastActivity = safeGetItem("nexus_last_active");
     const now = Date.now();
     const SESSION_TIMEOUT = 30 * 60 * 1e3;
     const isExpired = !sid || !lastActivity || now - parseInt(lastActivity, 10) > SESSION_TIMEOUT;
     if (isExpired) {
-      const uuid = crypto.randomUUID().replace(/-/g, "").substring(0, 16);
+      const uuid = generateUUID().replace(/-/g, "").substring(0, 16);
       sid = `sess_${uuid}_${now}`;
-      localStorage.setItem("nexus_sid", sid);
+      safeSetItem("nexus_sid", sid);
       this.sessionStart = now;
     }
-    localStorage.setItem("nexus_last_active", now.toString());
+    safeSetItem("nexus_last_active", now.toString());
     this.sessionId = sid;
   }
-  async send(eventType, data = {}, eventName) {
+  async send(eventType, data = {}, eventName, ecommerce) {
     if (typeof window === "undefined") return;
-    localStorage.setItem("nexus_last_active", Date.now().toString());
+    safeSetItem("nexus_last_active", Date.now().toString());
     const entropy = await getDeviceEntropy();
     const perfMetrics = vitalsCollector.getMetricsSnapshot();
+    const utmParams = extractUtmParams(window.location.href);
     const payload = {
       projectId: this.config.projectId,
       sessionId: this.sessionId,
+      visitorId: this.visitorId,
+      anonymousId: this.anonymousId,
+      messageId: generateUUID(),
+      sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+      version: SDK_VERSION,
       url: window.location.href,
       referrer: document.referrer,
       userAgent: window.navigator.userAgent,
@@ -1533,6 +1600,7 @@ var Tracker = class {
       eventType,
       eventName,
       eventData: data,
+      ecommerce: _nullishCoalesce(ecommerce, () => ( void 0)),
       performance: perfMetrics || void 0,
       context: {
         device: {
@@ -1542,7 +1610,8 @@ var Tracker = class {
           canvasFingerprint: entropy.canvas_hash,
           platform: entropy.platform
         },
-        visitorIdLocal: this.visitorId
+        visitorIdLocal: this.visitorId,
+        utm: utmParams
       },
       clientTimestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
@@ -1610,9 +1679,19 @@ var Tracker = class {
   getSession() {
     return this.sessionId;
   }
+  getVisitorId() {
+    return this.visitorId;
+  }
+  getAnonymousId() {
+    return this.anonymousId;
+  }
   getSessionDuration() {
     return Date.now() - this.sessionStart;
   }
+  clearIdentity() {
+    safeRemoveItem("nexus_anon_id");
+    this.anonymousId = "";
+  }
   stop() {
     if (this.flushInterval) {
       clearInterval(this.flushInterval);
@@ -1620,13 +1699,42 @@ var Tracker = class {
     this.flushQueue(true);
   }
 };
+function extractUtmParams(url) {
+  try {
+    const params = new URL(url).searchParams;
+    const utmKeys = [
+      "utm_source",
+      "utm_medium",
+      "utm_campaign",
+      "utm_term",
+      "utm_content"
+    ];
+    const result = {};
+    utmKeys.forEach((key) => {
+      const val = params.get(key);
+      if (val) result[key] = val;
+    });
+    return result;
+  } catch (e9) {
+    return {};
+  }
+}
 
 // src/analytics/index.ts
+var safeRemoveItem2 = (key) => {
+  try {
+    localStorage.removeItem(key);
+  } catch (e10) {
+  }
+};
 var AnalyticsEngine = class {
   constructor(config) {
     this.cleanupFns = [];
     this.isInitialized = false;
+    this.maxScrollDepth = 0;
+    this.scrollThresholdsFired = /* @__PURE__ */ new Set();
     this.lastPath = typeof window !== "undefined" ? window.location.pathname : "";
+    this.clickBuffer = [];
     this.tracker = new Tracker(config);
   }
   start() {
@@ -1638,6 +1746,10 @@ var AnalyticsEngine = class {
     this.setupFormTracking();
     this.setupRouteTracking();
     this.setupShareTracking();
+    this.setupScrollTracking();
+    this.setupOutboundTracking();
+    this.setupVideoTracking();
+    this.setupErrorTracking();
     if (process.env.NODE_ENV === "development") {
       console.log("[NexusHub] \u{1F680} Analytics Engine Started");
     }
@@ -1645,17 +1757,17 @@ var AnalyticsEngine = class {
   pageView(customReferrer) {
     if (typeof window === "undefined") return;
     const currentPath = window.location.pathname;
+    this.maxScrollDepth = 0;
+    this.scrollThresholdsFired.clear();
     this.tracker.send("page_view", {
       path: currentPath,
       search: window.location.search,
       title: document.title,
       timezone_offset: (/* @__PURE__ */ new Date()).getTimezoneOffset(),
-      // Use the virtual path as referrer if navigating internally
       referrer: customReferrer || (this.lastPath !== currentPath ? this.lastPath : document.referrer)
     });
     this.lastPath = currentPath;
   }
-  // --- SOCIAL / DARK SOCIAL TRACKING ---
   setupShareTracking() {
     if (typeof window === "undefined") return;
     const copyHandler = () => {
@@ -1681,92 +1793,36 @@ var AnalyticsEngine = class {
       });
     }
   }
-  // --- IDENTITY & B2B ---
-  async identify(userId, traits = {}) {
-    return this.sendIdentityRequest("identify", { user_id: userId, traits });
-  }
-  async group(groupId, traits = {}) {
-    return this.sendIdentityRequest("group", { group_id: groupId, traits });
-  }
-  async alias(newId) {
-    return this.sendIdentityRequest("alias", {
-      previous_id: this.tracker.getSession(),
-      user_id: newId
-    });
-  }
-  reset(performGdprScrub = false) {
-    const config = this.tracker.config;
-    this.tracker.stop();
-    localStorage.removeItem("nexus_sid");
-    localStorage.removeItem("nexus_vid");
-    if (performGdprScrub) {
-      const endpoint = `${config.analyticsUrl}/api/privacy/scrub`;
-      const userId = this.tracker.visitorId;
-      fetch(endpoint, {
-        method: "DELETE",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${config.apiKey}`
-        },
-        body: JSON.stringify({
-          project_id: config.projectId,
-          user_id: userId
-        })
-      }).catch((err) => console.error("[NexusHub] Privacy scrub failed:", err));
-    }
-    window.location.reload();
-  }
-  // --- E-COMMERCE & CUSTOM ---
-  track(eventName, properties = {}) {
-    this.tracker.send(
-      "custom_event",
-      { event_name: eventName, ...properties },
-      eventName
-    );
-  }
-  trackPurchase(orderData) {
-    this.tracker.send("purchase", {
-      ...orderData,
-      currency: orderData.currency || "USD",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    });
-  }
-  trackError(error, context) {
-    this.tracker.send("error", {
-      message: error.message,
-      stack: error.stack,
-      context,
-      url: typeof window !== "undefined" ? window.location.href : ""
-    });
-  }
-  // --- INTERNAL ---
-  async sendIdentityRequest(type, data) {
-    try {
-      const config = this.tracker.config;
-      const endpoint = `${config.analyticsUrl}/api/${type}`;
-      const payload = {
-        projectId: config.projectId,
-        sessionId: this.tracker.getSession(),
-        visitorId: this.tracker.visitorId,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        ...data
-      };
-      const response = await fetch(endpoint, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${config.apiKey}`
-        },
-        body: JSON.stringify(payload)
-      });
-      if (response.ok) {
-        return true;
+  setupScrollTracking() {
+    if (typeof window === "undefined") return;
+    const THRESHOLDS = [25, 50, 75, 100];
+    const scrollHandler = () => {
+      const scrollTop = window.scrollY || document.documentElement.scrollTop;
+      const docHeight = document.documentElement.scrollHeight - document.documentElement.clientHeight;
+      if (docHeight <= 0) return;
+      const pct = Math.round(scrollTop / docHeight * 100);
+      if (pct > this.maxScrollDepth) {
+        this.maxScrollDepth = pct;
       }
-      return false;
-    } catch (error) {
-      console.error(`[NexusHub] ${type} failed:`, error);
-      return false;
-    }
+      clearTimeout(this.scrollTimer);
+      this.scrollTimer = setTimeout(() => {
+        for (const threshold of THRESHOLDS) {
+          if (this.maxScrollDepth >= threshold && !this.scrollThresholdsFired.has(threshold)) {
+            this.scrollThresholdsFired.add(threshold);
+            this.tracker.send("scroll_depth", {
+              depth: threshold / 100,
+              depth_percent: threshold,
+              path: window.location.pathname
+            });
+          }
+        }
+      }, 300);
+    };
+    window.addEventListener("scroll", scrollHandler, { passive: true });
+    this.cleanupFns.push(() => {
+      window.removeEventListener("scroll", scrollHandler);
+      clearTimeout(this.scrollTimer);
+    });
   }
   setupClickTracking() {
     if (typeof window === "undefined") return;
@@ -1794,6 +1850,55 @@ var AnalyticsEngine = class {
           coordinates: { x: e.clientX, y: e.clientY }
         });
       }
+      const now = Date.now();
+      const ZONE = 400;
+      const WINDOW_MS = 1e3;
+      const RAGE_THRESHOLD = 3;
+      this.clickBuffer.push({ x: e.clientX, y: e.clientY, t: now });
+      this.clickBuffer = this.clickBuffer.filter((c) => now - c.t < WINDOW_MS);
+      const zone = {
+        x: Math.floor(e.clientX / ZONE),
+        y: Math.floor(e.clientY / ZONE)
+      };
+      const zoneClicks = this.clickBuffer.filter(
+        (c) => Math.floor(c.x / ZONE) === zone.x && Math.floor(c.y / ZONE) === zone.y
+      );
+      if (zoneClicks.length >= RAGE_THRESHOLD) {
+        this.tracker.send(
+          "click",
+          {
+            element_type: target.tagName.toLowerCase(),
+            event_name: "rage_click",
+            coordinates: { x: e.clientX, y: e.clientY },
+            click_count: zoneClicks.length,
+            path: window.location.pathname
+          },
+          "rage_click"
+        );
+        this.clickBuffer = [];
+      }
+      const isInteractive = target.closest(
+        "a, button, input, select, textarea, [onclick], [role='button']"
+      );
+      if (!isInteractive) {
+        const pathBefore = window.location.pathname;
+        setTimeout(() => {
+          const pathAfter = window.location.pathname;
+          if (pathBefore === pathAfter) {
+            this.tracker.send(
+              "click",
+              {
+                element_type: target.tagName.toLowerCase(),
+                event_name: "dead_click",
+                selector: getSelector(target),
+                coordinates: { x: e.clientX, y: e.clientY },
+                path: window.location.pathname
+              },
+              "dead_click"
+            );
+          }
+        }, 300);
+      }
     };
     window.addEventListener("click", clickHandler, { passive: true });
     this.cleanupFns.push(
@@ -1818,6 +1923,132 @@ var AnalyticsEngine = class {
       () => document.removeEventListener("submit", submitHandler)
     );
   }
+  setupOutboundTracking() {
+    if (typeof window === "undefined") return;
+    const outboundHandler = (e) => {
+      const link = e.target.closest("a");
+      if (!link || !link.href) return;
+      try {
+        const linkHost = new URL(link.href).hostname;
+        if (linkHost && linkHost !== window.location.hostname) {
+          this.tracker.send(
+            "click",
+            {
+              event_name: "outbound_click",
+              href: link.href,
+              text: _optionalChain([link, 'access', _35 => _35.innerText, 'optionalAccess', _36 => _36.substring, 'call', _37 => _37(0, 50)]),
+              destination_host: linkHost,
+              coordinates: { x: e.clientX, y: e.clientY }
+            },
+            "outbound_click"
+          );
+        }
+      } catch (e11) {
+      }
+    };
+    window.addEventListener("click", outboundHandler, { passive: true });
+    this.cleanupFns.push(
+      () => window.removeEventListener("click", outboundHandler)
+    );
+  }
+  setupVideoTracking() {
+    if (typeof document === "undefined") return;
+    const attachVideoListeners = (video) => {
+      if (video.__nexus_tracked) return;
+      video.__nexus_tracked = true;
+      const src = video.src || video.currentSrc || "unknown";
+      let milestone50Fired = false;
+      video.addEventListener("play", () => {
+        this.tracker.send(
+          "custom_event",
+          { event_name: "video_play", src },
+          "video_play"
+        );
+      });
+      video.addEventListener("pause", () => {
+        this.tracker.send(
+          "custom_event",
+          {
+            event_name: "video_pause",
+            src,
+            position_seconds: Math.round(video.currentTime)
+          },
+          "video_pause"
+        );
+      });
+      video.addEventListener("timeupdate", () => {
+        if (!video.duration || video.duration === Infinity) return;
+        const pct = video.currentTime / video.duration;
+        if (pct >= 0.5 && !milestone50Fired) {
+          milestone50Fired = true;
+          this.tracker.send(
+            "custom_event",
+            {
+              event_name: "video_50_percent",
+              src
+            },
+            "video_50_percent"
+          );
+        }
+      });
+      video.addEventListener("ended", () => {
+        this.tracker.send(
+          "custom_event",
+          {
+            event_name: "video_complete",
+            src,
+            duration_seconds: Math.round(video.duration)
+          },
+          "video_complete"
+        );
+      });
+    };
+    document.querySelectorAll("video").forEach((v) => attachVideoListeners(v));
+    const observer = new MutationObserver((mutations) => {
+      mutations.forEach((m) => {
+        m.addedNodes.forEach((node) => {
+          if (node instanceof HTMLVideoElement) {
+            attachVideoListeners(node);
+          }
+          if (node instanceof Element) {
+            node.querySelectorAll("video").forEach((v) => attachVideoListeners(v));
+          }
+        });
+      });
+    });
+    observer.observe(document.body, { childList: true, subtree: true });
+    this.cleanupFns.push(() => observer.disconnect());
+  }
+  setupErrorTracking() {
+    if (typeof window === "undefined") return;
+    const errorHandler = (e) => {
+      this.tracker.send("error", {
+        message: e.message,
+        filename: e.filename,
+        lineno: e.lineno,
+        colno: e.colno,
+        stack: _optionalChain([e, 'access', _38 => _38.error, 'optionalAccess', _39 => _39.stack]),
+        url: window.location.href,
+        type: "uncaught_error"
+      });
+    };
+    const rejectionHandler = (e) => {
+      const reason = e.reason instanceof Error ? e.reason.message : String(e.reason);
+      const stack = e.reason instanceof Error ? e.reason.stack : void 0;
+      this.tracker.send("error", {
+        message: reason,
+        stack,
+        url: window.location.href,
+        type: "unhandled_rejection"
+      });
+    };
+    window.addEventListener("error", errorHandler);
+    window.addEventListener("unhandledrejection", rejectionHandler);
+    this.cleanupFns.push(() => {
+      window.removeEventListener("error", errorHandler);
+      window.removeEventListener("unhandledrejection", rejectionHandler);
+    });
+  }
   setupRouteTracking() {
     if (typeof window === "undefined" || typeof window.history === "undefined")
       return;
@@ -1845,10 +2076,108 @@ var AnalyticsEngine = class {
       window.removeEventListener("popstate", popStateHandler);
     });
   }
-  // Simple flag to check if NexusProvider is active
   isInitializedByReactProvider() {
     return !!document.getElementById("__nexus_react_active");
   }
+  async identify(userId, traits = {}) {
+    return this.sendIdentityRequest("identify", { user_id: userId, traits });
+  }
+  async group(groupId, traits = {}) {
+    return this.sendIdentityRequest("group", { group_id: groupId, traits });
+  }
+  async alias(newId) {
+    return this.sendIdentityRequest("alias", {
+      previous_id: this.tracker.getSession(),
+      user_id: newId
+    });
+  }
+  reset(performGdprScrub = false) {
+    const config = this.tracker.config;
+    this.tracker.stop();
+    localStorage.removeItem("nexus_sid");
+    localStorage.removeItem("nexus_vid");
+    safeRemoveItem2("nexus_anon_id");
+    this.tracker.clearIdentity();
+    if (performGdprScrub) {
+      const endpoint = `${config.analyticsUrl}/api/privacy/scrub`;
+      const userId = this.tracker.getVisitorId();
+      fetch(endpoint, {
+        method: "DELETE",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${config.apiKey}`
+        },
+        body: JSON.stringify({
+          project_id: config.projectId,
+          user_id: userId
+        })
+      }).catch((err) => console.error("[NexusHub] Privacy scrub failed:", err));
+    }
+    window.location.reload();
+  }
+  track(eventName, properties = {}) {
+    this.tracker.send(
+      "custom_event",
+      { event_name: eventName, ...properties },
+      eventName
+    );
+  }
+  trackPurchase(orderData) {
+    const ecommerce = {
+      orderId: orderData.orderId,
+      total: orderData.total,
+      revenue: _nullishCoalesce(orderData.revenue, () => ( orderData.total)),
+      currency: orderData.currency || "USD",
+      products: orderData.products.map((p) => ({
+        productId: p.id,
+        sku: p.sku,
+        name: p.name,
+        price: p.price,
+        quantity: p.quantity
+      }))
+    };
+    this.tracker.send(
+      "purchase",
+      { order_id: orderData.orderId },
+      "purchase",
+      ecommerce
+    );
+  }
+  trackError(error, context) {
+    this.tracker.send("error", {
+      message: error.message,
+      stack: error.stack,
+      context,
+      url: typeof window !== "undefined" ? window.location.href : "",
+      type: "manual"
+    });
+  }
+  async sendIdentityRequest(type, data) {
+    try {
+      const config = this.tracker.config;
+      const endpoint = `${config.analyticsUrl}/api/${type}`;
+      const payload = {
+        projectId: config.projectId,
+        sessionId: this.tracker.getSession(),
+        visitorId: this.tracker.getVisitorId(),
+        anonymousId: this.tracker.getAnonymousId(),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        ...data
+      };
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${config.apiKey}`
+        },
+        body: JSON.stringify(payload)
+      });
+      return response.ok;
+    } catch (error) {
+      console.error(`[NexusHub] ${type} failed:`, error);
+      return false;
+    }
+  }
   getSessionId() {
     return this.tracker.getSession();
   }
@@ -1858,24 +2187,34 @@ var AnalyticsEngine = class {
     if (isFinalShutdown) {
       this.tracker.send("session_end", {
         session_id: this.tracker.getSession(),
-        duration: this.tracker.getSessionDuration()
+        duration: this.tracker.getSessionDuration(),
+        max_scroll_depth: this.maxScrollDepth / 100
       });
     }
     this.tracker.stop();
     this.isInitialized = false;
   }
 };
+function getSelector(el, depth = 0) {
+  if (!el || depth > 2) return "";
+  const tag = el.tagName.toLowerCase();
+  const id = el.id ? `#${el.id}` : "";
+  const cls = el.className && typeof el.className === "string" ? `.${el.className.trim().split(/\s+/).slice(0, 2).join(".")}` : "";
+  const self = `${tag}${id}${cls}`;
+  const parent = el.parentElement && depth < 2 ? `${getSelector(el.parentElement, depth + 1)} > ` : "";
+  return `${parent}${self}`;
+}
 
 // src/client.ts
 var NexusClient = class {
   constructor(config) {
     const fullConfig = getFullConfig(config);
     this.config = {
-      debug: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _35 => _35.debug]), () => ( false)),
-      cacheStrategy: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _36 => _36.cacheStrategy]), () => ( "memory")),
-      revalidateTime: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _37 => _37.revalidateTime]), () => ( 60)),
-      timeout: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _38 => _38.timeout]), () => ( 1e4)),
-      retries: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _39 => _39.retries]), () => ( 3)),
+      debug: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _40 => _40.debug]), () => ( false)),
+      cacheStrategy: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _41 => _41.cacheStrategy]), () => ( "memory")),
+      revalidateTime: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _42 => _42.revalidateTime]), () => ( 60)),
+      timeout: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _43 => _43.timeout]), () => ( 1e4)),
+      retries: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _44 => _44.retries]), () => ( 3)),
       ...fullConfig
     };
     const errors = validateConfig(this.config);
@@ -1922,6 +2261,8 @@ var createNexusClient = (config) => new NexusClient(config);
 
 
 
+
+
 var _react = require('react'); var _react2 = _interopRequireDefault(_react);
 var _navigation = require('next/navigation');
 
@@ -2111,7 +2452,7 @@ async function parseError(res) {
       code: json.code || "UNKNOWN_ERROR",
       message: json.message || "An error occurred during authentication"
     };
-  } catch (e6) {
+  } catch (e12) {
     return {
       status: res.status,
       code: "NETWORK_ERROR",
@@ -2123,6 +2464,10 @@ async function parseError(res) {
 // src/components/NexusProvider.tsx
 
 var NexusContext = _react.createContext.call(void 0, nexus);
+var NexusLiveFeedContext = _react.createContext.call(void 0, {
+  latestEvent: null,
+  isConnected: false
+});
 function NexusAnalyticsTracker({
   disableAnalytics
 }) {
@@ -2141,9 +2486,24 @@ function NexusAnalyticsTracker({
 var NexusProvider = ({
   children,
   projectId,
-  disableAnalytics = false
+  disableAnalytics = false,
+  hasConsent = true,
+  // NEW: default true to preserve existing behaviour
+  enableLiveFeed = false,
+  // NEW
+  onLiveEvent
+  // NEW
 }) => {
   const isInitialized = _react.useRef.call(void 0, false);
+  const socketRef = _react.useRef.call(void 0, null);
+  const [latestEvent, setLatestEvent] = _react.useState.call(void 0, 
+    null
+  );
+  const [isConnected, setIsConnected] = _react.useState.call(void 0, false);
+  const liveFeedValue = _react.useMemo.call(void 0, 
+    () => ({ latestEvent, isConnected }),
+    [latestEvent, isConnected]
+  );
   const config = _react.useMemo.call(void 0, () => {
     if (projectId && nexus.getConfig().projectId !== projectId) {
       nexus.updateConfig({ projectId });
@@ -2151,7 +2511,8 @@ var NexusProvider = ({
     return nexus.getConfig();
   }, [projectId]);
   _react.useEffect.call(void 0, () => {
-    if (typeof window === "undefined" || disableAnalytics) return;
+    if (typeof window === "undefined" || disableAnalytics || !hasConsent)
+      return;
     if (!isInitialized.current) {
       if (!nexus.analytics) {
         nexus.analytics = new AnalyticsEngine(nexus.getConfig());
@@ -2168,11 +2529,53 @@ var NexusProvider = ({
         isInitialized.current = false;
       }
     };
-  }, [disableAnalytics]);
-  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, NexusContext.Provider, { value: nexus, children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, AuthProvider, { config, children: [
+  }, [disableAnalytics, hasConsent]);
+  const connectLiveFeed = _react.useCallback.call(void 0, async () => {
+    if (typeof window === "undefined" || !enableLiveFeed) return;
+    try {
+      const { io } = await Promise.resolve().then(() => _interopRequireWildcard(require("socket.io-client")));
+      const cfg = nexus.getConfig();
+      const wsUrl = cfg.apiUrl || "http://localhost:3001";
+      const socket = io(`${wsUrl}/analytics`, {
+        auth: { token: cfg.apiKey },
+        query: { projectId: cfg.projectId },
+        transports: ["websocket"],
+        reconnectionAttempts: 5,
+        reconnectionDelay: 2e3
+      });
+      socket.on("connect", () => {
+        setIsConnected(true);
+        if (cfg.debug) console.log("[NexusHub] \u{1F534} Live feed connected");
+      });
+      socket.on("disconnect", () => {
+        setIsConnected(false);
+        if (cfg.debug) console.log("[NexusHub] Live feed disconnected");
+      });
+      socket.on("live_event", (event) => {
+        setLatestEvent(event);
+        _optionalChain([onLiveEvent, 'optionalCall', _45 => _45(event)]);
+      });
+      socketRef.current = socket;
+    } catch (err) {
+      console.error("[NexusHub] Live feed connection failed:", err);
+    }
+  }, [enableLiveFeed, onLiveEvent]);
+  _react.useEffect.call(void 0, () => {
+    if (enableLiveFeed) {
+      connectLiveFeed();
+    }
+    return () => {
+      if (socketRef.current) {
+        socketRef.current.disconnect();
+        socketRef.current = null;
+        setIsConnected(false);
+      }
+    };
+  }, [enableLiveFeed, connectLiveFeed]);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, NexusContext.Provider, { value: nexus, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, NexusLiveFeedContext.Provider, { value: liveFeedValue, children: /* @__PURE__ */ _jsxruntime.jsxs.call(void 0, AuthProvider, { config, children: [
     /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _react.Suspense, { fallback: null, children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, NexusAnalyticsTracker, { disableAnalytics }) }),
     children
-  ] }) });
+  ] }) }) });
 };
 var useNexus = () => {
   const context = _react2.default.useContext(NexusContext);