@hifilabs/pixel 0.1.6 → 0.2.0

package/dist/index.js

@@ -35,6 +35,8 @@ var __publicField = (obj, key, value) => {
 var src_exports = {};
 __export(src_exports, {
   BalanceAnalytics: () => BalanceAnalytics,
+  BalanceContext: () => BalanceContext,
+  BalanceProvider: () => BalanceProvider,
   DEFAULT_GTM_CONSENT: () => DEFAULT_GTM_CONSENT,
   GTMProvider: () => GTMProvider,
   StorageManager: () => StorageManager,
@@ -50,21 +52,2721 @@ __export(src_exports, {
   purchase: () => purchase,
   setConsent: () => setConsent,
   track: () => track,
+  useBalance: () => useBalance,
+  useBalanceAB: () => useBalanceAB,
+  useBalanceAuth: () => useBalanceAuth,
+  useBalanceConsent: () => useBalanceConsent,
+  useBalanceEcommerce: () => useBalanceEcommerce,
+  useBalanceEngagement: () => useBalanceEngagement,
+  useBalanceError: () => useBalanceError,
+  useBalanceForm: () => useBalanceForm,
   useBalanceIdentify: () => useBalanceIdentify,
+  useBalanceLive: () => useBalanceLive,
+  useBalanceMedia: () => useBalanceMedia,
+  useBalanceNotification: () => useBalanceNotification,
+  useBalanceOptional: () => useBalanceOptional,
+  useBalanceReady: () => useBalanceReady,
+  useBalanceSearch: () => useBalanceSearch,
+  useBalanceSocial: () => useBalanceSocial,
+  useBalanceSubscription: () => useBalanceSubscription,
   useGTMConsent: () => useGTMConsent
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/react/BalanceContext.ts
+var import_react = require("react");
+var warnNoProvider = (method) => {
+  if (true) {
+    console.warn(
+      `[BalanceContext] Called '${method}()' without <BalanceProvider>. Wrap your app with <BalanceProvider artistId="..."> to enable tracking.`
+    );
+  }
+};
+var defaultContextValue = {
+  // Tracking methods - warn in dev if Provider missing
+  track: () => warnNoProvider("track"),
+  identify: () => warnNoProvider("identify"),
+  page: () => warnNoProvider("page"),
+  purchase: () => warnNoProvider("purchase"),
+  // Getter methods - return defaults (no warning needed)
+  getSessionId: () => null,
+  getFanIdHash: () => null,
+  getAttribution: () => ({}),
+  // Consent methods - warn in dev if Provider missing
+  setConsent: () => warnNoProvider("setConsent"),
+  getConsent: () => null,
+  hasConsent: () => false,
+  // State - SSR-safe defaults
+  isReady: false,
+  artistId: "",
+  projectId: void 0,
+  endpoint: void 0,
+  debug: false
+};
+var BalanceContext = (0, import_react.createContext)(defaultContextValue);
+BalanceContext.displayName = "BalanceContext";
+
+// src/react/BalanceProvider.tsx
+var import_react4 = __toESM(require("react"));
+var import_script2 = __toESM(require("next/script"));
+
+// src/react/GTMProvider.tsx
+var import_react3 = __toESM(require("react"));
+var import_script = __toESM(require("next/script"));
+
+// src/react/useGTMConsent.ts
+var import_react2 = require("react");
+function useGTMConsent(options = {}) {
+  const { pollInterval = 1e3, debug = false, enabled = true } = options;
+  const lastConsentRef = (0, import_react2.useRef)("");
+  const log = (0, import_react2.useCallback)(
+    (...args) => {
+      if (debug) {
+        console.log("[useGTMConsent]", ...args);
+      }
+    },
+    [debug]
+  );
+  const mapPixelConsentToGTM = (0, import_react2.useCallback)(() => {
+    if (typeof window === "undefined" || !window.balance) {
+      return {
+        ad_storage: "denied",
+        ad_user_data: "denied",
+        ad_personalization: "denied",
+        analytics_storage: "denied"
+      };
+    }
+    const hasAnalytics = window.balance.hasConsent("analytics");
+    const hasMarketing = window.balance.hasConsent("marketing");
+    const analyticsState = hasAnalytics ? "granted" : "denied";
+    const marketingState = hasMarketing ? "granted" : "denied";
+    return {
+      analytics_storage: analyticsState,
+      ad_storage: marketingState,
+      ad_user_data: marketingState,
+      ad_personalization: marketingState
+    };
+  }, []);
+  const updateGTMConsent = (0, import_react2.useCallback)(
+    (consentConfig) => {
+      if (typeof window === "undefined")
+        return;
+      window.dataLayer = window.dataLayer || [];
+      if (typeof window.gtag !== "function") {
+        window.gtag = function gtag(...args) {
+          window.dataLayer.push(args);
+        };
+      }
+      window.gtag("consent", "update", consentConfig);
+      log("Pushed consent update to GTM:", consentConfig);
+    },
+    [log]
+  );
+  const syncConsent = (0, import_react2.useCallback)(() => {
+    const currentConsent = mapPixelConsentToGTM();
+    const consentKey = JSON.stringify(currentConsent);
+    if (consentKey !== lastConsentRef.current) {
+      lastConsentRef.current = consentKey;
+      updateGTMConsent(currentConsent);
+    }
+  }, [mapPixelConsentToGTM, updateGTMConsent]);
+  (0, import_react2.useEffect)(() => {
+    if (typeof window === "undefined" || !enabled)
+      return;
+    syncConsent();
+    const intervalId = setInterval(syncConsent, pollInterval);
+    const handleStorageChange = (e) => {
+      if (e.key === "balance_consent") {
+        log("Consent changed in another tab, syncing...");
+        syncConsent();
+      }
+    };
+    window.addEventListener("storage", handleStorageChange);
+    return () => {
+      clearInterval(intervalId);
+      window.removeEventListener("storage", handleStorageChange);
+    };
+  }, [syncConsent, pollInterval, log, enabled]);
+  return {
+    /**
+     * Manually trigger a consent sync
+     */
+    syncConsent,
+    /**
+     * Get current consent config
+     */
+    getConsentConfig: mapPixelConsentToGTM
+  };
+}
+
+// src/types/gtm.ts
+var DEFAULT_GTM_CONSENT = {
+  ad_storage: "denied",
+  ad_user_data: "denied",
+  ad_personalization: "denied",
+  analytics_storage: "denied"
+};
+
+// src/react/GTMProvider.tsx
+function GTMProvider({ gtmId, children, debug = false }) {
+  const resolvedGtmId = gtmId || process.env.NEXT_PUBLIC_GTM_ID;
+  useGTMConsent({ debug, enabled: !!resolvedGtmId });
+  if (!resolvedGtmId) {
+    if (debug) {
+      console.log("[GTMProvider] No GTM ID configured, skipping GTM initialization");
+    }
+    return /* @__PURE__ */ import_react3.default.createElement(import_react3.default.Fragment, null, children);
+  }
+  const consentJson = JSON.stringify(DEFAULT_GTM_CONSENT);
+  const consentScript = `
+    window.dataLayer = window.dataLayer || [];
+    function gtag(){dataLayer.push(arguments);}
+    window.gtag = gtag;
+    gtag('consent', 'default', ${consentJson});
+    gtag('set', 'wait_for_update', 500);
+    ${debug ? "console.log('[GTM] Default consent initialized (denied)');" : ""}
+  `;
+  return /* @__PURE__ */ import_react3.default.createElement(import_react3.default.Fragment, null, /* @__PURE__ */ import_react3.default.createElement(
+    import_script.default,
+    {
+      id: "gtm-consent-default",
+      strategy: "beforeInteractive",
+      dangerouslySetInnerHTML: { __html: consentScript }
+    }
+  ), /* @__PURE__ */ import_react3.default.createElement(
+    import_script.default,
+    {
+      id: "gtm-script",
+      strategy: "afterInteractive",
+      dangerouslySetInnerHTML: {
+        __html: `
+            (function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
+            new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
+            j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
+            'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
+            })(window,document,'script','dataLayer','${resolvedGtmId}');
+          `
+      }
+    }
+  ), /* @__PURE__ */ import_react3.default.createElement("noscript", null, /* @__PURE__ */ import_react3.default.createElement(
+    "iframe",
+    {
+      src: `https://www.googletagmanager.com/ns.html?id=${resolvedGtmId}`,
+      height: "0",
+      width: "0",
+      style: { display: "none", visibility: "hidden" },
+      title: "GTM"
+    }
+  )), children);
+}
+
+// src/react/BalanceProvider.tsx
+var DEFAULT_SCRIPT_URL = "https://cdn.hifilabs.co/balance-pixel.js";
+function ensureGlobalStub() {
+  if (typeof window === "undefined")
+    return;
+  if (!window.balance) {
+    window.balance = function(...args) {
+      (window.balance.q = window.balance.q || []).push(args);
+    };
+  }
+}
+function BalanceProvider({
+  artistId,
+  projectId,
+  debug = false,
+  gtmId,
+  scriptUrl,
+  endpoint,
+  useEmulator = false,
+  children
+}) {
+  const [isReady, setIsReady] = (0, import_react4.useState)(false);
+  const [shouldLoadScript, setShouldLoadScript] = (0, import_react4.useState)(false);
+  (0, import_react4.useEffect)(() => {
+    ensureGlobalStub();
+    const existingScript = document.querySelector(
+      'script[src*="balance-pixel"], script[data-artist-id]'
+    );
+    if (existingScript || window.balance?.version) {
+      if (debug) {
+        console.log("[BalanceProvider] Pixel already loaded externally");
+      }
+      setIsReady(true);
+      return;
+    }
+    setShouldLoadScript(true);
+  }, [debug]);
+  const track2 = (0, import_react4.useCallback)((event, properties) => {
+    if (typeof window === "undefined")
+      return;
+    ensureGlobalStub();
+    window.balance("track", event, properties || {});
+  }, []);
+  const identify2 = (0, import_react4.useCallback)((email, traits) => {
+    if (typeof window === "undefined")
+      return;
+    ensureGlobalStub();
+    window.balance("identify", email, traits || {});
+  }, []);
+  const page2 = (0, import_react4.useCallback)((options) => {
+    if (typeof window === "undefined")
+      return;
+    ensureGlobalStub();
+    window.balance("page", options || {});
+  }, []);
+  const purchase2 = (0, import_react4.useCallback)((amount, currency, properties) => {
+    if (typeof window === "undefined")
+      return;
+    ensureGlobalStub();
+    window.balance("purchase", amount, currency || "USD", properties || {});
+  }, []);
+  const getSessionId2 = (0, import_react4.useCallback)(() => {
+    if (typeof window === "undefined")
+      return null;
+    return window.balance?.getSessionId?.() ?? null;
+  }, []);
+  const getFanIdHash2 = (0, import_react4.useCallback)(() => {
+    if (typeof window === "undefined")
+      return null;
+    return window.balance?.getFanIdHash?.() ?? null;
+  }, []);
+  const getAttribution2 = (0, import_react4.useCallback)(() => {
+    if (typeof window === "undefined")
+      return {};
+    return window.balance?.getAttribution?.() ?? {};
+  }, []);
+  const setConsent2 = (0, import_react4.useCallback)((preferences) => {
+    if (typeof window === "undefined")
+      return;
+    ensureGlobalStub();
+    window.balance("setConsent", preferences);
+  }, []);
+  const getConsent2 = (0, import_react4.useCallback)(() => {
+    if (typeof window === "undefined")
+      return null;
+    return window.balance?.getConsent?.() ?? null;
+  }, []);
+  const hasConsent2 = (0, import_react4.useCallback)((type) => {
+    if (typeof window === "undefined")
+      return false;
+    return window.balance?.hasConsent?.(type) ?? false;
+  }, []);
+  const contextValue = (0, import_react4.useMemo)(() => ({
+    // Tracking methods (always usable via queue)
+    track: track2,
+    identify: identify2,
+    page: page2,
+    purchase: purchase2,
+    // Getter methods
+    getSessionId: getSessionId2,
+    getFanIdHash: getFanIdHash2,
+    getAttribution: getAttribution2,
+    // Consent methods
+    setConsent: setConsent2,
+    getConsent: getConsent2,
+    hasConsent: hasConsent2,
+    // State
+    isReady,
+    artistId,
+    projectId,
+    endpoint,
+    debug
+  }), [
+    track2,
+    identify2,
+    page2,
+    purchase2,
+    getSessionId2,
+    getFanIdHash2,
+    getAttribution2,
+    setConsent2,
+    getConsent2,
+    hasConsent2,
+    isReady,
+    artistId,
+    projectId,
+    endpoint,
+    debug
+  ]);
+  const handleScriptLoad = (0, import_react4.useCallback)(() => {
+    if (debug) {
+      console.log("[BalanceProvider] Pixel script loaded");
+    }
+    setIsReady(true);
+  }, [debug]);
+  const handleScriptError = (0, import_react4.useCallback)((e) => {
+    console.error("[BalanceProvider] Failed to load pixel script:", e);
+  }, []);
+  const resolvedScriptUrl = scriptUrl ?? DEFAULT_SCRIPT_URL;
+  const content = /* @__PURE__ */ import_react4.default.createElement(BalanceContext.Provider, { value: contextValue }, shouldLoadScript && /* @__PURE__ */ import_react4.default.createElement(
+    import_script2.default,
+    {
+      src: resolvedScriptUrl,
+      "data-artist-id": artistId,
+      "data-project-id": projectId,
+      "data-endpoint": endpoint,
+      "data-emulator": useEmulator ? "true" : void 0,
+      "data-debug": debug ? "true" : void 0,
+      strategy: "afterInteractive",
+      onLoad: handleScriptLoad,
+      onError: handleScriptError
+    }
+  ), children);
+  if (gtmId) {
+    return /* @__PURE__ */ import_react4.default.createElement(GTMProvider, { gtmId, debug }, content);
+  }
+  return content;
+}
+
+// src/react/useBalance.ts
+var import_react5 = require("react");
+function useBalance() {
+  const context = (0, import_react5.useContext)(BalanceContext);
+  if (!context.artistId) {
+    throw new Error(
+      '[useBalance] must be used within a BalanceProvider. Wrap your app with <BalanceProvider artistId="..."> or use useBalanceOptional() instead.'
+    );
+  }
+  return context;
+}
+function useBalanceOptional() {
+  const context = (0, import_react5.useContext)(BalanceContext);
+  if (!context.artistId) {
+    return null;
+  }
+  return context;
+}
+
+// src/react/useBalanceConsent.ts
+var import_react6 = require("react");
+function useBalanceConsent() {
+  const { setConsent: setConsent2, getConsent: getConsent2, hasConsent: hasConsent2 } = useBalance();
+  const acceptAll = (0, import_react6.useCallback)(() => {
+    setConsent2({
+      analytics: true,
+      marketing: true,
+      personalization: true,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }, [setConsent2]);
+  const declineAll = (0, import_react6.useCallback)(() => {
+    setConsent2({
+      analytics: false,
+      marketing: false,
+      personalization: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }, [setConsent2]);
+  const acceptAnalyticsOnly = (0, import_react6.useCallback)(() => {
+    setConsent2({
+      analytics: true,
+      marketing: false,
+      personalization: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }, [setConsent2]);
+  return {
+    setConsent: setConsent2,
+    getConsent: getConsent2,
+    hasConsent: hasConsent2,
+    acceptAll,
+    declineAll,
+    acceptAnalyticsOnly
+  };
+}
+
+// src/react/useBalanceReady.ts
+var import_react7 = require("react");
+function useBalanceReady() {
+  const context = (0, import_react7.useContext)(BalanceContext);
+  return context.isReady;
+}
+
+// src/react/useBalanceEcommerce.ts
+var import_react8 = require("react");
+function useBalanceEcommerce() {
+  const { track: track2, purchase: purchase2 } = useBalance();
+  const formatProduct = (0, import_react8.useCallback)((product, quantity) => ({
+    item_id: product.id,
+    item_name: product.name,
+    price: product.price,
+    item_category: product.category,
+    item_variant: product.variant,
+    item_brand: product.brand,
+    quantity: quantity ?? product.quantity ?? 1
+  }), []);
+  const formatProducts = (0, import_react8.useCallback)(
+    (products) => products.map((p, index) => ({
+      ...formatProduct(p),
+      index
+    })),
+    [formatProduct]
+  );
+  const calculateValue = (0, import_react8.useCallback)(
+    (items) => items.reduce((sum, item) => sum + item.price * (item.quantity || 1), 0),
+    []
+  );
+  const viewProduct = (0, import_react8.useCallback)((product) => {
+    track2("view_item", {
+      currency: "USD",
+      value: product.price,
+      items: [formatProduct(product)]
+    });
+  }, [track2, formatProduct]);
+  const viewProductList = (0, import_react8.useCallback)((listName, products) => {
+    track2("view_item_list", {
+      item_list_id: listName.toLowerCase().replace(/\s+/g, "_"),
+      item_list_name: listName,
+      items: formatProducts(products)
+    });
+  }, [track2, formatProducts]);
+  const selectProduct = (0, import_react8.useCallback)((product, listName) => {
+    track2("select_item", {
+      item_list_name: listName,
+      items: [formatProduct(product)]
+    });
+  }, [track2, formatProduct]);
+  const addToCart = (0, import_react8.useCallback)((product, quantity = 1) => {
+    track2("add_to_cart", {
+      currency: "USD",
+      value: product.price * quantity,
+      items: [formatProduct(product, quantity)]
+    });
+  }, [track2, formatProduct]);
+  const removeFromCart = (0, import_react8.useCallback)((product, quantity = 1) => {
+    track2("remove_from_cart", {
+      currency: "USD",
+      value: product.price * quantity,
+      items: [formatProduct(product, quantity)]
+    });
+  }, [track2, formatProduct]);
+  const viewCart = (0, import_react8.useCallback)((items, cartTotal) => {
+    track2("view_cart", {
+      currency: "USD",
+      value: cartTotal,
+      items: formatProducts(items)
+    });
+  }, [track2, formatProducts]);
+  const beginCheckout = (0, import_react8.useCallback)((items, total, currency = "USD") => {
+    track2("begin_checkout", {
+      currency,
+      value: total,
+      items: formatProducts(items)
+    });
+  }, [track2, formatProducts]);
+  const addShippingInfo = (0, import_react8.useCallback)((shippingTier, items) => {
+    track2("add_shipping_info", {
+      currency: "USD",
+      value: calculateValue(items),
+      shipping_tier: shippingTier,
+      items: formatProducts(items)
+    });
+  }, [track2, formatProducts, calculateValue]);
+  const addPaymentInfo = (0, import_react8.useCallback)((paymentType, items) => {
+    track2("add_payment_info", {
+      currency: "USD",
+      value: calculateValue(items),
+      payment_type: paymentType,
+      items: formatProducts(items)
+    });
+  }, [track2, formatProducts, calculateValue]);
+  const completePurchase = (0, import_react8.useCallback)((orderId, total, items, options = {}) => {
+    const { currency = "USD", tax, shipping, coupon } = options;
+    purchase2(total, currency, {
+      order_id: orderId,
+      tax,
+      shipping,
+      coupon,
+      items: formatProducts(items)
+    });
+  }, [purchase2, formatProducts]);
+  const refund = (0, import_react8.useCallback)((orderId, amount, items) => {
+    track2("refund", {
+      currency: "USD",
+      transaction_id: orderId,
+      value: amount,
+      items: items ? formatProducts(items) : void 0
+    });
+  }, [track2, formatProducts]);
+  return {
+    // Product discovery
+    viewProduct,
+    viewProductList,
+    selectProduct,
+    // Cart operations
+    addToCart,
+    removeFromCart,
+    viewCart,
+    // Checkout flow
+    beginCheckout,
+    addShippingInfo,
+    addPaymentInfo,
+    // Purchase & refund
+    completePurchase,
+    refund
+  };
+}
+
+// src/react/useBalanceMedia.ts
+var import_react9 = require("react");
+function useBalanceMedia() {
+  const { track: track2 } = useBalance();
+  const playStartRef = (0, import_react9.useRef)(null);
+  const totalListenTimeRef = (0, import_react9.useRef)(0);
+  const milestonesTrackedRef = (0, import_react9.useRef)(/* @__PURE__ */ new Set());
+  const currentMediaIdRef = (0, import_react9.useRef)(null);
+  const isPlayingRef = (0, import_react9.useRef)(false);
+  const formatMedia = (0, import_react9.useCallback)((media) => ({
+    media_id: media.mediaId,
+    title: media.title,
+    duration: media.duration,
+    type: media.type,
+    artist: media.artist,
+    album: media.album,
+    genre: media.genre,
+    playlist: media.playlist,
+    playlist_position: media.playlistPosition
+  }), []);
+  const getListenDuration = (0, import_react9.useCallback)(() => {
+    let duration = totalListenTimeRef.current;
+    if (isPlayingRef.current && playStartRef.current) {
+      duration += (Date.now() - playStartRef.current) / 1e3;
+    }
+    return Math.round(duration * 100) / 100;
+  }, []);
+  const reset = (0, import_react9.useCallback)(() => {
+    playStartRef.current = null;
+    totalListenTimeRef.current = 0;
+    milestonesTrackedRef.current.clear();
+    currentMediaIdRef.current = null;
+    isPlayingRef.current = false;
+  }, []);
+  const play = (0, import_react9.useCallback)((media) => {
+    if (currentMediaIdRef.current !== media.mediaId) {
+      reset();
+      currentMediaIdRef.current = media.mediaId;
+    }
+    playStartRef.current = Date.now();
+    isPlayingRef.current = true;
+    track2("media_play", {
+      ...formatMedia(media),
+      session_listen_time: totalListenTimeRef.current
+    });
+  }, [track2, formatMedia, reset]);
+  const pause = (0, import_react9.useCallback)((media, currentTime) => {
+    if (playStartRef.current && isPlayingRef.current) {
+      totalListenTimeRef.current += (Date.now() - playStartRef.current) / 1e3;
+    }
+    playStartRef.current = null;
+    isPlayingRef.current = false;
+    const percentPlayed = media.duration > 0 ? Math.round(currentTime / media.duration * 100) : 0;
+    track2("media_pause", {
+      ...formatMedia(media),
+      current_time: currentTime,
+      percent_played: percentPlayed,
+      session_listen_time: totalListenTimeRef.current
+    });
+  }, [track2, formatMedia]);
+  const complete = (0, import_react9.useCallback)((media) => {
+    if (playStartRef.current && isPlayingRef.current) {
+      totalListenTimeRef.current += (Date.now() - playStartRef.current) / 1e3;
+    }
+    isPlayingRef.current = false;
+    track2("media_complete", {
+      ...formatMedia(media),
+      session_listen_time: totalListenTimeRef.current
+    });
+    reset();
+  }, [track2, formatMedia, reset]);
+  const seek = (0, import_react9.useCallback)((media, fromTime, toTime) => {
+    track2("media_seek", {
+      ...formatMedia(media),
+      from_time: fromTime,
+      to_time: toTime,
+      seek_distance: Math.abs(toTime - fromTime),
+      seek_direction: toTime > fromTime ? "forward" : "backward"
+    });
+  }, [track2, formatMedia]);
+  const trackProgress = (0, import_react9.useCallback)((media, currentTime) => {
+    if (media.duration <= 0)
+      return;
+    const percentPlayed = currentTime / media.duration * 100;
+    const milestones = [25, 50, 75, 90];
+    milestones.forEach((milestone) => {
+      if (percentPlayed >= milestone && !milestonesTrackedRef.current.has(milestone)) {
+        milestonesTrackedRef.current.add(milestone);
+        track2("media_progress", {
+          ...formatMedia(media),
+          milestone,
+          current_time: currentTime,
+          session_listen_time: getListenDuration()
+        });
+      }
+    });
+  }, [track2, formatMedia, getListenDuration]);
+  const buffer = (0, import_react9.useCallback)((media, currentTime) => {
+    track2("media_buffer", {
+      ...formatMedia(media),
+      current_time: currentTime,
+      percent_played: media.duration > 0 ? Math.round(currentTime / media.duration * 100) : 0
+    });
+  }, [track2, formatMedia]);
+  const qualityChange = (0, import_react9.useCallback)((media, fromQuality, toQuality) => {
+    track2("media_quality_change", {
+      ...formatMedia(media),
+      from_quality: fromQuality,
+      to_quality: toQuality
+    });
+  }, [track2, formatMedia]);
+  const volumeChange = (0, import_react9.useCallback)((media, volume, muted) => {
+    track2("media_volume_change", {
+      ...formatMedia(media),
+      volume: Math.round(volume * 100),
+      muted
+    });
+  }, [track2, formatMedia]);
+  const speedChange = (0, import_react9.useCallback)((media, speed) => {
+    track2("media_speed_change", {
+      ...formatMedia(media),
+      playback_speed: speed
+    });
+  }, [track2, formatMedia]);
+  return {
+    // Core playback
+    play,
+    pause,
+    complete,
+    seek,
+    // Progress tracking
+    trackProgress,
+    // Quality & settings
+    buffer,
+    qualityChange,
+    volumeChange,
+    speedChange,
+    // Utilities
+    reset,
+    getListenDuration
+  };
+}
+
+// src/react/useBalanceEngagement.ts
+var import_react10 = require("react");
+function useBalanceEngagement(contentId, contentTitle) {
+  const { track: track2 } = useBalance();
+  const scrollMilestonesRef = (0, import_react10.useRef)(/* @__PURE__ */ new Set());
+  const pageLoadTimeRef = (0, import_react10.useRef)(null);
+  const isTrackingTimeRef = (0, import_react10.useRef)(false);
+  const timeIntervalsRef = (0, import_react10.useRef)([30, 60, 120, 300]);
+  const timeTrackedRef = (0, import_react10.useRef)(/* @__PURE__ */ new Set());
+  const getBaseProps = (0, import_react10.useCallback)(() => ({
+    content_id: contentId,
+    content_title: contentTitle
+  }), [contentId, contentTitle]);
+  const getTimeOnPage = (0, import_react10.useCallback)(() => {
+    if (!pageLoadTimeRef.current)
+      return 0;
+    return Math.round((Date.now() - pageLoadTimeRef.current) / 1e3);
+  }, []);
+  const reset = (0, import_react10.useCallback)(() => {
+    scrollMilestonesRef.current.clear();
+    pageLoadTimeRef.current = null;
+    isTrackingTimeRef.current = false;
+    timeTrackedRef.current.clear();
+  }, []);
+  const share = (0, import_react10.useCallback)((platform, contentType) => {
+    track2("content_shared", {
+      ...getBaseProps(),
+      platform,
+      content_type: contentType,
+      time_on_page: getTimeOnPage()
+    });
+  }, [track2, getBaseProps, getTimeOnPage]);
+  const like = (0, import_react10.useCallback)((contentType) => {
+    track2("content_liked", {
+      ...getBaseProps(),
+      content_type: contentType,
+      time_on_page: getTimeOnPage()
+    });
+  }, [track2, getBaseProps, getTimeOnPage]);
+  const unlike = (0, import_react10.useCallback)((contentType) => {
+    track2("content_unliked", {
+      ...getBaseProps(),
+      content_type: contentType
+    });
+  }, [track2, getBaseProps]);
+  const comment = (0, import_react10.useCallback)((commentLength) => {
+    track2("comment_added", {
+      ...getBaseProps(),
+      comment_length: commentLength,
+      time_on_page: getTimeOnPage()
+    });
+  }, [track2, getBaseProps, getTimeOnPage]);
+  const save = (0, import_react10.useCallback)((contentType) => {
+    track2("content_saved", {
+      ...getBaseProps(),
+      content_type: contentType,
+      time_on_page: getTimeOnPage()
+    });
+  }, [track2, getBaseProps, getTimeOnPage]);
+  const trackScrollDepth = (0, import_react10.useCallback)((scrollPercent) => {
+    const milestones = [25, 50, 75, 100];
+    milestones.forEach((milestone) => {
+      if (scrollPercent >= milestone && !scrollMilestonesRef.current.has(milestone)) {
+        scrollMilestonesRef.current.add(milestone);
+        track2("scroll_depth", {
+          ...getBaseProps(),
+          depth: milestone,
+          time_on_page: getTimeOnPage()
+        });
+      }
+    });
+  }, [track2, getBaseProps, getTimeOnPage]);
+  const trackTimeOnPage = (0, import_react10.useCallback)(() => {
+    if (isTrackingTimeRef.current)
+      return;
+    pageLoadTimeRef.current = Date.now();
+    isTrackingTimeRef.current = true;
+    const intervalId = setInterval(() => {
+      const timeOnPage = getTimeOnPage();
+      timeIntervalsRef.current.forEach((milestone) => {
+        if (timeOnPage >= milestone && !timeTrackedRef.current.has(milestone)) {
+          timeTrackedRef.current.add(milestone);
+          track2("time_on_page", {
+            ...getBaseProps(),
+            seconds: milestone,
+            scroll_depth: Math.max(...Array.from(scrollMilestonesRef.current), 0)
+          });
+        }
+      });
+      const maxMilestone = Math.max(...timeIntervalsRef.current);
+      if (timeOnPage > maxMilestone) {
+        clearInterval(intervalId);
+      }
+    }, 5e3);
+    return () => clearInterval(intervalId);
+  }, [track2, getBaseProps, getTimeOnPage]);
+  const click = (0, import_react10.useCallback)((elementType, elementId) => {
+    track2("content_click", {
+      ...getBaseProps(),
+      element_type: elementType,
+      element_id: elementId,
+      time_on_page: getTimeOnPage()
+    });
+  }, [track2, getBaseProps, getTimeOnPage]);
+  const copy = (0, import_react10.useCallback)((textLength) => {
+    track2("content_copied", {
+      ...getBaseProps(),
+      text_length: textLength,
+      time_on_page: getTimeOnPage()
+    });
+  }, [track2, getBaseProps, getTimeOnPage]);
+  const download = (0, import_react10.useCallback)((fileName, fileType) => {
+    track2("content_downloaded", {
+      ...getBaseProps(),
+      file_name: fileName,
+      file_type: fileType,
+      time_on_page: getTimeOnPage()
+    });
+  }, [track2, getBaseProps, getTimeOnPage]);
+  const expand = (0, import_react10.useCallback)((sectionName) => {
+    track2("content_expanded", {
+      ...getBaseProps(),
+      section_name: sectionName,
+      time_on_page: getTimeOnPage()
+    });
+  }, [track2, getBaseProps, getTimeOnPage]);
+  (0, import_react10.useEffect)(() => {
+    return () => {
+      if (isTrackingTimeRef.current && pageLoadTimeRef.current) {
+        const finalTime = getTimeOnPage();
+        const maxScrollDepth = Math.max(...Array.from(scrollMilestonesRef.current), 0);
+        if (finalTime > 5) {
+          track2("content_exit", {
+            ...getBaseProps(),
+            time_on_page: finalTime,
+            max_scroll_depth: maxScrollDepth
+          });
+        }
+      }
+    };
+  }, [track2, getBaseProps, getTimeOnPage]);
+  return {
+    // Social engagement
+    share,
+    like,
+    unlike,
+    comment,
+    save,
+    // Scroll tracking
+    trackScrollDepth,
+    // Time tracking
+    trackTimeOnPage,
+    getTimeOnPage,
+    // Click & interaction
+    click,
+    copy,
+    download,
+    expand,
+    // Utilities
+    reset
+  };
+}
+
+// src/react/useBalanceForm.ts
+var import_react11 = require("react");
+function useBalanceForm(formId, formName) {
+  const { track: track2, identify: identify2 } = useBalance();
+  const startTimeRef = (0, import_react11.useRef)(null);
+  const fieldsRef = (0, import_react11.useRef)(/* @__PURE__ */ new Map());
+  const wasSubmittedRef = (0, import_react11.useRef)(false);
+  const hasStartedRef = (0, import_react11.useRef)(false);
+  const currentStepRef = (0, import_react11.useRef)(1);
+  const errorCountRef = (0, import_react11.useRef)(0);
+  const getBaseProps = (0, import_react11.useCallback)(() => ({
+    form_id: formId,
+    form_name: formName
+  }), [formId, formName]);
+  const getFormDuration = (0, import_react11.useCallback)(() => {
+    if (!startTimeRef.current)
+      return 0;
+    return Math.round((Date.now() - startTimeRef.current) / 1e3);
+  }, []);
+  const getFieldsCompleted = (0, import_react11.useCallback)(() => {
+    return Array.from(fieldsRef.current.values()).filter((f) => f.completed).length;
+  }, []);
+  const hasStarted = (0, import_react11.useCallback)(() => {
+    return hasStartedRef.current;
+  }, []);
+  const wasSubmitted = (0, import_react11.useCallback)(() => {
+    return wasSubmittedRef.current;
+  }, []);
+  const reset = (0, import_react11.useCallback)(() => {
+    startTimeRef.current = null;
+    fieldsRef.current.clear();
+    wasSubmittedRef.current = false;
+    hasStartedRef.current = false;
+    currentStepRef.current = 1;
+    errorCountRef.current = 0;
+  }, []);
+  const formStart = (0, import_react11.useCallback)(() => {
+    if (hasStartedRef.current)
+      return;
+    startTimeRef.current = Date.now();
+    hasStartedRef.current = true;
+    track2("form_started", {
+      ...getBaseProps()
+    });
+  }, [track2, getBaseProps]);
+  const formSubmit = (0, import_react11.useCallback)((email, additionalData) => {
+    wasSubmittedRef.current = true;
+    const duration = getFormDuration();
+    const fieldsCompleted = getFieldsCompleted();
+    const totalFields = fieldsRef.current.size;
+    if (email) {
+      identify2(email, {
+        source: formId,
+        form_name: formName,
+        ...additionalData
+      });
+    }
+    track2("form_submitted", {
+      ...getBaseProps(),
+      duration_seconds: duration,
+      fields_completed: fieldsCompleted,
+      total_fields: totalFields,
+      error_count: errorCountRef.current,
+      current_step: currentStepRef.current,
+      ...additionalData
+    });
+  }, [track2, identify2, getBaseProps, getFormDuration, getFieldsCompleted, formId, formName]);
+  const formAbandoned = (0, import_react11.useCallback)((reason) => {
+    if (!hasStartedRef.current || wasSubmittedRef.current)
+      return;
+    const duration = getFormDuration();
+    const fieldsCompleted = getFieldsCompleted();
+    const totalFields = fieldsRef.current.size;
+    let lastField;
+    let lastInteractionTime = 0;
+    fieldsRef.current.forEach((field, name) => {
+      const time = field.blurTime || field.focusTime;
+      if (time > lastInteractionTime) {
+        lastInteractionTime = time;
+        lastField = name;
+      }
+    });
+    track2("form_abandoned", {
+      ...getBaseProps(),
+      duration_seconds: duration,
+      fields_completed: fieldsCompleted,
+      total_fields: totalFields,
+      last_field: lastField,
+      current_step: currentStepRef.current,
+      error_count: errorCountRef.current,
+      reason
+    });
+  }, [track2, getBaseProps, getFormDuration, getFieldsCompleted]);
+  const fieldFocus = (0, import_react11.useCallback)((fieldName, fieldType) => {
+    if (!hasStartedRef.current) {
+      formStart();
+    }
+    const existing = fieldsRef.current.get(fieldName);
+    if (!existing) {
+      fieldsRef.current.set(fieldName, {
+        name: fieldName,
+        type: fieldType,
+        focusTime: Date.now(),
+        completed: false,
+        errorCount: 0
+      });
+      track2("field_focused", {
+        ...getBaseProps(),
+        field_name: fieldName,
+        field_type: fieldType,
+        field_order: fieldsRef.current.size,
+        time_to_field: getFormDuration()
+      });
+    } else {
+      existing.focusTime = Date.now();
+    }
+  }, [track2, getBaseProps, getFormDuration, formStart]);
+  const fieldBlur = (0, import_react11.useCallback)((fieldName, fieldType, hasValue) => {
+    const field = fieldsRef.current.get(fieldName);
+    if (field) {
+      field.blurTime = Date.now();
+      field.completed = hasValue;
+      const timeInField = field.blurTime - field.focusTime;
+      track2("field_completed", {
+        ...getBaseProps(),
+        field_name: fieldName,
+        field_type: fieldType,
+        has_value: hasValue,
+        time_in_field_ms: timeInField
+      });
+    }
+  }, [track2, getBaseProps]);
+  const fieldError = (0, import_react11.useCallback)((fieldName, errorMessage) => {
+    errorCountRef.current += 1;
+    const field = fieldsRef.current.get(fieldName);
+    if (field) {
+      field.errorCount += 1;
+    }
+    track2("field_error", {
+      ...getBaseProps(),
+      field_name: fieldName,
+      error_message: errorMessage,
+      total_errors: errorCountRef.current
+    });
+  }, [track2, getBaseProps]);
+  const stepChange = (0, import_react11.useCallback)((fromStep, toStep, stepName) => {
+    currentStepRef.current = toStep;
+    track2("form_step_change", {
+      ...getBaseProps(),
+      from_step: fromStep,
+      to_step: toStep,
+      step_name: stepName,
+      direction: toStep > fromStep ? "forward" : "backward",
+      duration_seconds: getFormDuration(),
+      fields_completed: getFieldsCompleted()
+    });
+  }, [track2, getBaseProps, getFormDuration, getFieldsCompleted]);
+  return {
+    // Form lifecycle
+    formStart,
+    formSubmit,
+    formAbandoned,
+    // Field interactions
+    fieldFocus,
+    fieldBlur,
+    fieldError,
+    // Multi-step
+    stepChange,
+    // Utilities
+    getFormDuration,
+    getFieldsCompleted,
+    reset,
+    hasStarted,
+    wasSubmitted
+  };
+}
+
+// src/react/useBalanceSearch.ts
+var import_react12 = require("react");
+function useBalanceSearch(searchContext) {
+  const { track: track2 } = useBalance();
+  const searchCountRef = (0, import_react12.useRef)(0);
+  const clickCountRef = (0, import_react12.useRef)(0);
+  const filterCountRef = (0, import_react12.useRef)(0);
+  const activeFiltersRef = (0, import_react12.useRef)(/* @__PURE__ */ new Map());
+  const lastQueryRef = (0, import_react12.useRef)("");
+  const getBaseProps = (0, import_react12.useCallback)(() => ({
+    search_context: searchContext,
+    session_searches: searchCountRef.current,
+    session_clicks: clickCountRef.current
+  }), [searchContext]);
+  const getSearchStats = (0, import_react12.useCallback)(() => ({
+    searches: searchCountRef.current,
+    clicks: clickCountRef.current,
+    filters: filterCountRef.current
+  }), []);
+  const reset = (0, import_react12.useCallback)(() => {
+    searchCountRef.current = 0;
+    clickCountRef.current = 0;
+    filterCountRef.current = 0;
+    activeFiltersRef.current.clear();
+    lastQueryRef.current = "";
+  }, []);
+  const search = (0, import_react12.useCallback)((query, resultCount, searchType) => {
+    searchCountRef.current += 1;
+    lastQueryRef.current = query;
+    track2("search", {
+      ...getBaseProps(),
+      search_term: query,
+      search_type: searchType,
+      result_count: resultCount,
+      has_results: resultCount > 0,
+      active_filters: Array.from(activeFiltersRef.current.values()),
+      filter_count: activeFiltersRef.current.size
+    });
+  }, [track2, getBaseProps]);
+  const selectResult = (0, import_react12.useCallback)((query, resultId, position, resultType) => {
+    clickCountRef.current += 1;
+    track2("search_result_click", {
+      ...getBaseProps(),
+      search_term: query,
+      result_id: resultId,
+      result_position: position,
+      result_type: resultType
+    });
+  }, [track2, getBaseProps]);
+  const noResults = (0, import_react12.useCallback)((query, searchType) => {
+    searchCountRef.current += 1;
+    lastQueryRef.current = query;
+    track2("search_no_results", {
+      ...getBaseProps(),
+      search_term: query,
+      search_type: searchType,
+      active_filters: Array.from(activeFiltersRef.current.values()),
+      filter_count: activeFiltersRef.current.size
+    });
+  }, [track2, getBaseProps]);
+  const applyFilter = (0, import_react12.useCallback)((filter) => {
+    filterCountRef.current += 1;
+    const filterKey = `${filter.category}:${filter.value}`;
+    activeFiltersRef.current.set(filterKey, filter);
+    track2("search_filter_apply", {
+      ...getBaseProps(),
+      filter_category: filter.category,
+      filter_value: filter.value,
+      active_filter_count: activeFiltersRef.current.size,
+      last_query: lastQueryRef.current
+    });
+  }, [track2, getBaseProps]);
+  const removeFilter = (0, import_react12.useCallback)((filter) => {
+    const filterKey = `${filter.category}:${filter.value}`;
+    activeFiltersRef.current.delete(filterKey);
+    track2("search_filter_remove", {
+      ...getBaseProps(),
+      filter_category: filter.category,
+      filter_value: filter.value,
+      active_filter_count: activeFiltersRef.current.size,
+      last_query: lastQueryRef.current
+    });
+  }, [track2, getBaseProps]);
+  const clearFilters = (0, import_react12.useCallback)(() => {
+    const filterCount = activeFiltersRef.current.size;
+    activeFiltersRef.current.clear();
+    track2("search_filters_clear", {
+      ...getBaseProps(),
+      filters_cleared: filterCount,
+      last_query: lastQueryRef.current
+    });
+  }, [track2, getBaseProps]);
+  const showSuggestions = (0, import_react12.useCallback)((query, suggestions) => {
+    track2("search_suggestions_shown", {
+      ...getBaseProps(),
+      query,
+      suggestion_count: suggestions.length,
+      suggestions: suggestions.slice(0, 5)
+      // Limit to first 5
+    });
+  }, [track2, getBaseProps]);
+  const selectSuggestion = (0, import_react12.useCallback)((originalQuery, suggestion, position) => {
+    track2("search_suggestion_click", {
+      ...getBaseProps(),
+      original_query: originalQuery,
+      selected_suggestion: suggestion,
+      suggestion_position: position
+    });
+  }, [track2, getBaseProps]);
+  const refineSearch = (0, import_react12.useCallback)((originalQuery, newQuery) => {
+    track2("search_refined", {
+      ...getBaseProps(),
+      original_query: originalQuery,
+      refined_query: newQuery,
+      refinement_type: newQuery.includes(originalQuery) ? "extended" : "modified"
+    });
+  }, [track2, getBaseProps]);
+  const loadMoreResults = (0, import_react12.useCallback)((query, page2, resultsLoaded) => {
+    track2("search_load_more", {
+      ...getBaseProps(),
+      search_term: query,
+      page: page2,
+      total_results_loaded: resultsLoaded
+    });
+  }, [track2, getBaseProps]);
+  const voiceSearch = (0, import_react12.useCallback)((transcript, resultCount) => {
+    searchCountRef.current += 1;
+    lastQueryRef.current = transcript;
+    track2("voice_search", {
+      ...getBaseProps(),
+      transcript,
+      result_count: resultCount,
+      has_results: resultCount > 0
+    });
+  }, [track2, getBaseProps]);
+  return {
+    // Core search
+    search,
+    selectResult,
+    noResults,
+    // Filters
+    applyFilter,
+    removeFilter,
+    clearFilters,
+    // Suggestions
+    showSuggestions,
+    selectSuggestion,
+    // Advanced
+    refineSearch,
+    loadMoreResults,
+    voiceSearch,
+    // Utilities
+    getSearchStats,
+    reset
+  };
+}
+
+// src/react/useBalanceNotification.ts
+var import_react13 = require("react");
+function useBalanceNotification() {
+  const { track: track2 } = useBalance();
+  const shownCountRef = (0, import_react13.useRef)(0);
+  const clickedCountRef = (0, import_react13.useRef)(0);
+  const dismissedCountRef = (0, import_react13.useRef)(0);
+  const notificationsSeenRef = (0, import_react13.useRef)(/* @__PURE__ */ new Set());
+  const getBaseProps = (0, import_react13.useCallback)(() => ({
+    session_notifications_shown: shownCountRef.current,
+    session_notifications_clicked: clickedCountRef.current
+  }), []);
+  const getStats = (0, import_react13.useCallback)(() => {
+    const shown2 = shownCountRef.current;
+    const clicked2 = clickedCountRef.current;
+    const dismissed2 = dismissedCountRef.current;
+    const ctr = shown2 > 0 ? Math.round(clicked2 / shown2 * 100) : 0;
+    return { shown: shown2, clicked: clicked2, dismissed: dismissed2, ctr };
+  }, []);
+  const reset = (0, import_react13.useCallback)(() => {
+    shownCountRef.current = 0;
+    clickedCountRef.current = 0;
+    dismissedCountRef.current = 0;
+    notificationsSeenRef.current.clear();
+  }, []);
+  const shown = (0, import_react13.useCallback)((notificationId, type, campaign) => {
+    if (notificationsSeenRef.current.has(notificationId))
+      return;
+    notificationsSeenRef.current.add(notificationId);
+    shownCountRef.current += 1;
+    track2("notification_shown", {
+      ...getBaseProps(),
+      notification_id: notificationId,
+      notification_type: type,
+      campaign
+    });
+  }, [track2, getBaseProps]);
+  const clicked = (0, import_react13.useCallback)((notificationId, type, action) => {
+    clickedCountRef.current += 1;
+    track2("notification_clicked", {
+      ...getBaseProps(),
+      notification_id: notificationId,
+      notification_type: type,
+      action
+    });
+  }, [track2, getBaseProps]);
+  const dismissed = (0, import_react13.useCallback)((notificationId, type, reason) => {
+    dismissedCountRef.current += 1;
+    track2("notification_dismissed", {
+      ...getBaseProps(),
+      notification_id: notificationId,
+      notification_type: type,
+      dismiss_reason: reason
+    });
+  }, [track2, getBaseProps]);
+  const optIn = (0, import_react13.useCallback)((channel, source) => {
+    track2("notification_opt_in", {
+      ...getBaseProps(),
+      channel,
+      opt_in_source: source
+    });
+  }, [track2, getBaseProps]);
+  const optOut = (0, import_react13.useCallback)((channel, reason) => {
+    track2("notification_opt_out", {
+      ...getBaseProps(),
+      channel,
+      opt_out_reason: reason
+    });
+  }, [track2, getBaseProps]);
+  const permissionRequested = (0, import_react13.useCallback)((channel) => {
+    track2("notification_permission_requested", {
+      ...getBaseProps(),
+      channel
+    });
+  }, [track2, getBaseProps]);
+  const permissionDenied = (0, import_react13.useCallback)((channel) => {
+    track2("notification_permission_denied", {
+      ...getBaseProps(),
+      channel
+    });
+  }, [track2, getBaseProps]);
+  const preferenceUpdated = (0, import_react13.useCallback)((preferences) => {
+    track2("notification_preferences_updated", {
+      ...getBaseProps(),
+      preferences: preferences.map((p) => ({
+        channel: p.channel,
+        enabled: p.enabled,
+        frequency: p.frequency
+      })),
+      enabled_channels: preferences.filter((p) => p.enabled).map((p) => p.channel)
+    });
+  }, [track2, getBaseProps]);
+  const emailOpened = (0, import_react13.useCallback)((emailId, campaign, subject) => {
+    track2("email_opened", {
+      ...getBaseProps(),
+      email_id: emailId,
+      campaign,
+      subject
+    });
+  }, [track2, getBaseProps]);
+  const emailLinkClicked = (0, import_react13.useCallback)((emailId, linkUrl, linkName) => {
+    track2("email_link_clicked", {
+      ...getBaseProps(),
+      email_id: emailId,
+      link_url: linkUrl,
+      link_name: linkName
+    });
+  }, [track2, getBaseProps]);
+  const emailUnsubscribed = (0, import_react13.useCallback)((emailId, reason, category) => {
+    track2("email_unsubscribed", {
+      ...getBaseProps(),
+      email_id: emailId,
+      unsubscribe_reason: reason,
+      category
+    });
+  }, [track2, getBaseProps]);
+  const pushReceived = (0, import_react13.useCallback)((notificationId, campaign) => {
+    track2("push_received", {
+      ...getBaseProps(),
+      notification_id: notificationId,
+      campaign
+    });
+  }, [track2, getBaseProps]);
+  const inAppInteraction = (0, import_react13.useCallback)((messageId, interactionType, elementClicked) => {
+    if (interactionType === "view")
+      shownCountRef.current += 1;
+    if (interactionType === "click")
+      clickedCountRef.current += 1;
+    if (interactionType === "dismiss")
+      dismissedCountRef.current += 1;
+    track2("in_app_message_interaction", {
+      ...getBaseProps(),
+      message_id: messageId,
+      interaction_type: interactionType,
+      element_clicked: elementClicked
+    });
+  }, [track2, getBaseProps]);
+  return {
+    // Core events
+    shown,
+    clicked,
+    dismissed,
+    // Permission & opt-in
+    optIn,
+    optOut,
+    permissionRequested,
+    permissionDenied,
+    preferenceUpdated,
+    // Email
+    emailOpened,
+    emailLinkClicked,
+    emailUnsubscribed,
+    // Push & in-app
+    pushReceived,
+    inAppInteraction,
+    // Utilities
+    getStats,
+    reset
+  };
+}
+
+// src/react/useBalanceSocial.ts
+var import_react14 = require("react");
+function useBalanceSocial() {
+  const { track: track2 } = useBalance();
+  const followsRef = (0, import_react14.useRef)(0);
+  const unfollowsRef = (0, import_react14.useRef)(0);
+  const profileViewsRef = (0, import_react14.useRef)(0);
+  const postsCreatedRef = (0, import_react14.useRef)(0);
+  const viewedProfilesRef = (0, import_react14.useRef)(/* @__PURE__ */ new Set());
+  const getBaseProps = (0, import_react14.useCallback)(() => ({
+    session_follows: followsRef.current,
+    session_unfollows: unfollowsRef.current,
+    session_profile_views: profileViewsRef.current
+  }), []);
+  const getStats = (0, import_react14.useCallback)(() => ({
+    follows: followsRef.current,
+    unfollows: unfollowsRef.current,
+    profileViews: profileViewsRef.current,
+    postsCreated: postsCreatedRef.current
+  }), []);
+  const reset = (0, import_react14.useCallback)(() => {
+    followsRef.current = 0;
+    unfollowsRef.current = 0;
+    profileViewsRef.current = 0;
+    postsCreatedRef.current = 0;
+    viewedProfilesRef.current.clear();
+  }, []);
+  const viewProfile = (0, import_react14.useCallback)((entityId, entityType, source) => {
+    const profileKey = `${entityType}:${entityId}`;
+    const isFirstView = !viewedProfilesRef.current.has(profileKey);
+    if (isFirstView) {
+      viewedProfilesRef.current.add(profileKey);
+      profileViewsRef.current += 1;
+    }
+    track2("profile_viewed", {
+      ...getBaseProps(),
+      entity_id: entityId,
+      entity_type: entityType,
+      source,
+      is_first_view: isFirstView
+    });
+  }, [track2, getBaseProps]);
+  const follow = (0, import_react14.useCallback)((entityId, entityType, source) => {
+    followsRef.current += 1;
+    track2("follow", {
+      ...getBaseProps(),
+      entity_id: entityId,
+      entity_type: entityType,
+      source
+    });
+  }, [track2, getBaseProps]);
+  const unfollow = (0, import_react14.useCallback)((entityId, entityType, reason) => {
+    unfollowsRef.current += 1;
+    track2("unfollow", {
+      ...getBaseProps(),
+      entity_id: entityId,
+      entity_type: entityType,
+      reason
+    });
+  }, [track2, getBaseProps]);
+  const block = (0, import_react14.useCallback)((entityId, entityType, reason) => {
+    track2("block", {
+      ...getBaseProps(),
+      entity_id: entityId,
+      entity_type: entityType,
+      reason
+    });
+  }, [track2, getBaseProps]);
+  const mute = (0, import_react14.useCallback)((entityId, entityType) => {
+    track2("mute", {
+      ...getBaseProps(),
+      entity_id: entityId,
+      entity_type: entityType
+    });
+  }, [track2, getBaseProps]);
+  const report = (0, import_react14.useCallback)((entityId, entityType, reason, details) => {
+    track2("report", {
+      ...getBaseProps(),
+      entity_id: entityId,
+      entity_type: entityType,
+      reason,
+      details
+    });
+  }, [track2, getBaseProps]);
+  const mention = (0, import_react14.useCallback)((mentionedId, mentionedType, context) => {
+    track2("mention_sent", {
+      ...getBaseProps(),
+      mentioned_id: mentionedId,
+      mentioned_type: mentionedType,
+      context
+    });
+  }, [track2, getBaseProps]);
+  const wasMentioned = (0, import_react14.useCallback)((byUserId, context, contentId) => {
+    track2("mention_received", {
+      ...getBaseProps(),
+      by_user_id: byUserId,
+      context,
+      content_id: contentId
+    });
+  }, [track2, getBaseProps]);
+  const inviteSent = (0, import_react14.useCallback)((channel, recipientCount) => {
+    track2("invite_sent", {
+      ...getBaseProps(),
+      channel,
+      recipient_count: recipientCount || 1
+    });
+  }, [track2, getBaseProps]);
+  const inviteAccepted = (0, import_react14.useCallback)((inviteCode, inviterId) => {
+    track2("invite_accepted", {
+      ...getBaseProps(),
+      invite_code: inviteCode,
+      inviter_id: inviterId
+    });
+  }, [track2, getBaseProps]);
+  const joinCommunity = (0, import_react14.useCallback)((communityId, communityName, source) => {
+    track2("community_joined", {
+      ...getBaseProps(),
+      community_id: communityId,
+      community_name: communityName,
+      source
+    });
+  }, [track2, getBaseProps]);
+  const leaveCommunity = (0, import_react14.useCallback)((communityId, communityName, reason) => {
+    track2("community_left", {
+      ...getBaseProps(),
+      community_id: communityId,
+      community_name: communityName,
+      reason
+    });
+  }, [track2, getBaseProps]);
+  const createPost = (0, import_react14.useCallback)((postId, postType, communityId) => {
+    postsCreatedRef.current += 1;
+    track2("post_created", {
+      ...getBaseProps(),
+      post_id: postId,
+      post_type: postType,
+      community_id: communityId
+    });
+  }, [track2, getBaseProps]);
+  const replyToPost = (0, import_react14.useCallback)((postId, replyId, depth) => {
+    track2("reply_created", {
+      ...getBaseProps(),
+      post_id: postId,
+      reply_id: replyId,
+      depth: depth || 1
+    });
+  }, [track2, getBaseProps]);
+  const react = (0, import_react14.useCallback)((contentId, reactionType, contentType) => {
+    track2("reaction", {
+      ...getBaseProps(),
+      content_id: contentId,
+      reaction_type: reactionType,
+      content_type: contentType
+    });
+  }, [track2, getBaseProps]);
+  const editProfile = (0, import_react14.useCallback)((fieldsEdited) => {
+    track2("profile_edited", {
+      ...getBaseProps(),
+      fields_edited: fieldsEdited,
+      field_count: fieldsEdited.length
+    });
+  }, [track2, getBaseProps]);
+  const changeAvatar = (0, import_react14.useCallback)((source) => {
+    track2("avatar_changed", {
+      ...getBaseProps(),
+      source
+    });
+  }, [track2, getBaseProps]);
+  const connectionRequest = (0, import_react14.useCallback)((targetId, targetType) => {
+    track2("connection_requested", {
+      ...getBaseProps(),
+      target_id: targetId,
+      target_type: targetType
+    });
+  }, [track2, getBaseProps]);
+  const connectionAccepted = (0, import_react14.useCallback)((requesterId, requesterType) => {
+    track2("connection_accepted", {
+      ...getBaseProps(),
+      requester_id: requesterId,
+      requester_type: requesterType
+    });
+  }, [track2, getBaseProps]);
+  return {
+    // Profile & follow
+    viewProfile,
+    follow,
+    unfollow,
+    block,
+    mute,
+    report,
+    // Mentions
+    mention,
+    wasMentioned,
+    // Invites
+    inviteSent,
+    inviteAccepted,
+    // Community
+    joinCommunity,
+    leaveCommunity,
+    // Content
+    createPost,
+    replyToPost,
+    react,
+    // Profile management
+    editProfile,
+    changeAvatar,
+    // Connections
+    connectionRequest,
+    connectionAccepted,
+    // Utilities
+    getStats,
+    reset
+  };
+}
+
+// src/react/useBalanceAuth.ts
+var import_react15 = require("react");
+function useBalanceAuth() {
+  const { track: track2, identify: identify2 } = useBalance();
+  const loginAttemptsRef = (0, import_react15.useRef)(0);
+  const loginSuccessesRef = (0, import_react15.useRef)(0);
+  const loginFailuresRef = (0, import_react15.useRef)(0);
+  const authStartTimeRef = (0, import_react15.useRef)(null);
+  const getBaseProps = (0, import_react15.useCallback)(() => ({
+    session_login_attempts: loginAttemptsRef.current,
+    session_login_successes: loginSuccessesRef.current
+  }), []);
+  const getAuthDuration = (0, import_react15.useCallback)(() => {
+    if (!authStartTimeRef.current)
+      return 0;
+    return Math.round((Date.now() - authStartTimeRef.current) / 1e3);
+  }, []);
+  const getStats = (0, import_react15.useCallback)(() => ({
+    loginAttempts: loginAttemptsRef.current,
+    loginSuccesses: loginSuccessesRef.current,
+    loginFailures: loginFailuresRef.current
+  }), []);
+  const reset = (0, import_react15.useCallback)(() => {
+    loginAttemptsRef.current = 0;
+    loginSuccessesRef.current = 0;
+    loginFailuresRef.current = 0;
+    authStartTimeRef.current = null;
+  }, []);
+  const signUpStart = (0, import_react15.useCallback)((method, source) => {
+    authStartTimeRef.current = Date.now();
+    track2("sign_up_start", {
+      ...getBaseProps(),
+      method,
+      source
+    });
+  }, [track2, getBaseProps]);
+  const signUpSuccess = (0, import_react15.useCallback)((method, email) => {
+    loginSuccessesRef.current += 1;
+    if (email) {
+      identify2(email, { auth_method: method, signup_date: (/* @__PURE__ */ new Date()).toISOString() });
+    }
+    track2("sign_up", {
+      ...getBaseProps(),
+      method,
+      duration_seconds: getAuthDuration()
+    });
+    authStartTimeRef.current = null;
+  }, [track2, identify2, getBaseProps, getAuthDuration]);
+  const signUpFailed = (0, import_react15.useCallback)((method, errorCode, errorMessage) => {
+    loginFailuresRef.current += 1;
+    track2("sign_up_failed", {
+      ...getBaseProps(),
+      method,
+      error_code: errorCode,
+      error_message: errorMessage,
+      duration_seconds: getAuthDuration()
+    });
+  }, [track2, getBaseProps, getAuthDuration]);
+  const verificationSent = (0, import_react15.useCallback)((method) => {
+    track2("verification_sent", {
+      ...getBaseProps(),
+      method
+    });
+  }, [track2, getBaseProps]);
+  const verified = (0, import_react15.useCallback)((method) => {
+    track2("verified", {
+      ...getBaseProps(),
+      method
+    });
+  }, [track2, getBaseProps]);
+  const loginStart = (0, import_react15.useCallback)((method, source) => {
+    loginAttemptsRef.current += 1;
+    authStartTimeRef.current = Date.now();
+    track2("login_start", {
+      ...getBaseProps(),
+      method,
+      source
+    });
+  }, [track2, getBaseProps]);
+  const loginSuccess = (0, import_react15.useCallback)((method, email) => {
+    loginSuccessesRef.current += 1;
+    if (email) {
+      identify2(email, { auth_method: method, last_login: (/* @__PURE__ */ new Date()).toISOString() });
+    }
+    track2("login", {
+      ...getBaseProps(),
+      method,
+      duration_seconds: getAuthDuration()
+    });
+    authStartTimeRef.current = null;
+  }, [track2, identify2, getBaseProps, getAuthDuration]);
+  const loginFailed = (0, import_react15.useCallback)((method, errorCode, errorMessage) => {
+    loginFailuresRef.current += 1;
+    track2("login_failed", {
+      ...getBaseProps(),
+      method,
+      error_code: errorCode,
+      error_message: errorMessage,
+      duration_seconds: getAuthDuration()
+    });
+  }, [track2, getBaseProps, getAuthDuration]);
+  const logout = (0, import_react15.useCallback)((reason = "user_initiated") => {
+    track2("logout", {
+      ...getBaseProps(),
+      reason
+    });
+  }, [track2, getBaseProps]);
+  const passwordResetRequested = (0, import_react15.useCallback)((method) => {
+    track2("password_reset_requested", {
+      ...getBaseProps(),
+      method
+    });
+  }, [track2, getBaseProps]);
+  const passwordResetCompleted = (0, import_react15.useCallback)(() => {
+    track2("password_reset_completed", {
+      ...getBaseProps()
+    });
+  }, [track2, getBaseProps]);
+  const passwordChanged = (0, import_react15.useCallback)((source) => {
+    track2("password_changed", {
+      ...getBaseProps(),
+      source
+    });
+  }, [track2, getBaseProps]);
+  const mfaSetupStart = (0, import_react15.useCallback)((method) => {
+    track2("mfa_setup_start", {
+      ...getBaseProps(),
+      method
+    });
+  }, [track2, getBaseProps]);
+  const mfaSetupCompleted = (0, import_react15.useCallback)((method) => {
+    track2("mfa_setup_completed", {
+      ...getBaseProps(),
+      method
+    });
+  }, [track2, getBaseProps]);
+  const mfaChallenge = (0, import_react15.useCallback)((method) => {
+    track2("mfa_challenge", {
+      ...getBaseProps(),
+      method
+    });
+  }, [track2, getBaseProps]);
+  const mfaSuccess = (0, import_react15.useCallback)((method) => {
+    track2("mfa_success", {
+      ...getBaseProps(),
+      method
+    });
+  }, [track2, getBaseProps]);
+  const mfaFailed = (0, import_react15.useCallback)((method, reason) => {
+    track2("mfa_failed", {
+      ...getBaseProps(),
+      method,
+      reason
+    });
+  }, [track2, getBaseProps]);
+  const mfaDisabled = (0, import_react15.useCallback)((method) => {
+    track2("mfa_disabled", {
+      ...getBaseProps(),
+      method
+    });
+  }, [track2, getBaseProps]);
+  const sessionStart = (0, import_react15.useCallback)((isNewUser, authMethod) => {
+    track2("session_start", {
+      ...getBaseProps(),
+      is_new_user: isNewUser,
+      auth_method: authMethod
+    });
+  }, [track2, getBaseProps]);
+  const sessionResume = (0, import_react15.useCallback)(() => {
+    track2("session_resume", {
+      ...getBaseProps()
+    });
+  }, [track2, getBaseProps]);
+  const sessionExpired = (0, import_react15.useCallback)((durationSeconds) => {
+    track2("session_expired", {
+      ...getBaseProps(),
+      duration_seconds: durationSeconds
+    });
+  }, [track2, getBaseProps]);
+  const sessionRefreshed = (0, import_react15.useCallback)(() => {
+    track2("session_refreshed", {
+      ...getBaseProps()
+    });
+  }, [track2, getBaseProps]);
+  const accountDeletionRequested = (0, import_react15.useCallback)((reason) => {
+    track2("account_deletion_requested", {
+      ...getBaseProps(),
+      reason
+    });
+  }, [track2, getBaseProps]);
+  const accountDeleted = (0, import_react15.useCallback)((reason) => {
+    track2("account_deleted", {
+      ...getBaseProps(),
+      reason
+    });
+  }, [track2, getBaseProps]);
+  const accountLinked = (0, import_react15.useCallback)((method) => {
+    track2("account_linked", {
+      ...getBaseProps(),
+      method
+    });
+  }, [track2, getBaseProps]);
+  const accountUnlinked = (0, import_react15.useCallback)((method) => {
+    track2("account_unlinked", {
+      ...getBaseProps(),
+      method
+    });
+  }, [track2, getBaseProps]);
+  return {
+    // Sign up
+    signUpStart,
+    signUpSuccess,
+    signUpFailed,
+    verificationSent,
+    verified,
+    // Login
+    loginStart,
+    loginSuccess,
+    loginFailed,
+    logout,
+    // Password
+    passwordResetRequested,
+    passwordResetCompleted,
+    passwordChanged,
+    // MFA
+    mfaSetupStart,
+    mfaSetupCompleted,
+    mfaChallenge,
+    mfaSuccess,
+    mfaFailed,
+    mfaDisabled,
+    // Session
+    sessionStart,
+    sessionResume,
+    sessionExpired,
+    sessionRefreshed,
+    // Account
+    accountDeletionRequested,
+    accountDeleted,
+    accountLinked,
+    accountUnlinked,
+    // Utilities
+    getStats,
+    reset
+  };
+}
+
+// src/react/useBalanceError.ts
+var import_react16 = require("react");
+function useBalanceError() {
+  const { track: track2 } = useBalance();
+  const errorCountRef = (0, import_react16.useRef)(0);
+  const apiErrorCountRef = (0, import_react16.useRef)(0);
+  const userReportCountRef = (0, import_react16.useRef)(0);
+  const pageLoadTimesRef = (0, import_react16.useRef)([]);
+  const measureStartTimesRef = (0, import_react16.useRef)(/* @__PURE__ */ new Map());
+  const capturedErrorsRef = (0, import_react16.useRef)(/* @__PURE__ */ new Set());
+  const getBaseProps = (0, import_react16.useCallback)(() => ({
+    session_errors: errorCountRef.current,
+    session_api_errors: apiErrorCountRef.current,
+    page_url: typeof window !== "undefined" ? window.location.href : void 0,
+    user_agent: typeof navigator !== "undefined" ? navigator.userAgent : void 0
+  }), []);
+  const getErrorFingerprint = (0, import_react16.useCallback)((error) => {
+    return `${error.name}:${error.message}:${error.stack?.split("\n")[1] || ""}`;
+  }, []);
+  const getStats = (0, import_react16.useCallback)(() => {
+    const times = pageLoadTimesRef.current;
+    const avgPageLoad = times.length > 0 ? Math.round(times.reduce((a, b) => a + b, 0) / times.length) : null;
+    return {
+      errors: errorCountRef.current,
+      apiErrors: apiErrorCountRef.current,
+      userReports: userReportCountRef.current,
+      avgPageLoad
+    };
+  }, []);
+  const reset = (0, import_react16.useCallback)(() => {
+    errorCountRef.current = 0;
+    apiErrorCountRef.current = 0;
+    userReportCountRef.current = 0;
+    pageLoadTimesRef.current = [];
+    measureStartTimesRef.current.clear();
+    capturedErrorsRef.current.clear();
+  }, []);
+  const captureError = (0, import_react16.useCallback)((error, context, severity = "error") => {
+    const fingerprint = getErrorFingerprint(error);
+    if (capturedErrorsRef.current.has(fingerprint))
+      return;
+    capturedErrorsRef.current.add(fingerprint);
+    errorCountRef.current += 1;
+    track2("error_captured", {
+      ...getBaseProps(),
+      error_name: error.name,
+      error_message: error.message,
+      error_stack: error.stack?.slice(0, 1e3),
+      // Limit stack trace size
+      severity,
+      ...context
+    });
+  }, [track2, getBaseProps, getErrorFingerprint]);
+  const captureApiError = (0, import_react16.useCallback)((details, context) => {
+    apiErrorCountRef.current += 1;
+    track2("api_error", {
+      ...getBaseProps(),
+      api_url: details.url,
+      api_method: details.method || "GET",
+      status_code: details.statusCode,
+      response_body: details.responseBody?.slice(0, 500),
+      // Limit size
+      duration_ms: details.durationMs,
+      ...context
+    });
+  }, [track2, getBaseProps]);
+  const captureUserReport = (0, import_react16.useCallback)((category, description, metadata) => {
+    userReportCountRef.current += 1;
+    track2("user_report", {
+      ...getBaseProps(),
+      report_category: category,
+      report_description: description.slice(0, 1e3),
+      ...metadata
+    });
+  }, [track2, getBaseProps]);
+  const captureComponentError = (0, import_react16.useCallback)((error, componentName, componentStack) => {
+    errorCountRef.current += 1;
+    track2("component_error", {
+      ...getBaseProps(),
+      error_name: error.name,
+      error_message: error.message,
+      component_name: componentName,
+      component_stack: componentStack?.slice(0, 1e3)
+    });
+  }, [track2, getBaseProps]);
+  const captureUnhandledRejection = (0, import_react16.useCallback)((reason, promiseInfo) => {
+    errorCountRef.current += 1;
+    const message = reason instanceof Error ? reason.message : String(reason);
+    track2("unhandled_rejection", {
+      ...getBaseProps(),
+      rejection_reason: message.slice(0, 500),
+      promise_info: promiseInfo
+    });
+  }, [track2, getBaseProps]);
+  const captureResourceError = (0, import_react16.useCallback)((resourceUrl, resourceType, details) => {
+    track2("resource_error", {
+      ...getBaseProps(),
+      resource_url: resourceUrl,
+      resource_type: resourceType,
+      ...details
+    });
+  }, [track2, getBaseProps]);
+  const trackPerformance = (0, import_react16.useCallback)((metricType, valueMs, context) => {
+    if (metricType === "page_load") {
+      pageLoadTimesRef.current.push(valueMs);
+    }
+    track2("performance_metric", {
+      ...getBaseProps(),
+      metric_type: metricType,
+      value_ms: Math.round(valueMs),
+      ...context
+    });
+  }, [track2, getBaseProps]);
+  const trackWebVitals = (0, import_react16.useCallback)((vitals) => {
+    track2("web_vitals", {
+      ...getBaseProps(),
+      lcp_ms: vitals.lcp ? Math.round(vitals.lcp) : void 0,
+      fid_ms: vitals.fid ? Math.round(vitals.fid) : void 0,
+      cls_score: vitals.cls,
+      fcp_ms: vitals.fcp ? Math.round(vitals.fcp) : void 0,
+      ttfb_ms: vitals.ttfb ? Math.round(vitals.ttfb) : void 0
+    });
+  }, [track2, getBaseProps]);
+  const trackSlowInteraction = (0, import_react16.useCallback)((interactionType, durationMs, targetElement) => {
+    track2("slow_interaction", {
+      ...getBaseProps(),
+      interaction_type: interactionType,
+      duration_ms: Math.round(durationMs),
+      target_element: targetElement
+    });
+  }, [track2, getBaseProps]);
+  const startMeasure = (0, import_react16.useCallback)((measureName) => {
+    measureStartTimesRef.current.set(measureName, performance.now());
+  }, []);
+  const endMeasure = (0, import_react16.useCallback)((measureName, metricType = "interaction") => {
+    const startTime = measureStartTimesRef.current.get(measureName);
+    if (!startTime)
+      return null;
+    const duration = performance.now() - startTime;
+    measureStartTimesRef.current.delete(measureName);
+    trackPerformance(metricType, duration, { measure_name: measureName });
+    return Math.round(duration);
+  }, [trackPerformance]);
+  return {
+    // Error capture
+    captureError,
+    captureApiError,
+    captureUserReport,
+    captureComponentError,
+    captureUnhandledRejection,
+    captureResourceError,
+    // Performance
+    trackPerformance,
+    trackWebVitals,
+    trackSlowInteraction,
+    // Measurement
+    startMeasure,
+    endMeasure,
+    // Utilities
+    getStats,
+    reset
+  };
+}
+
+// src/react/useBalanceAB.ts
+var import_react17 = require("react");
+function useBalanceAB() {
+  const { track: track2 } = useBalance();
+  const exposuresRef = (0, import_react17.useRef)(0);
+  const conversionsRef = (0, import_react17.useRef)(0);
+  const activeExperimentsRef = (0, import_react17.useRef)(/* @__PURE__ */ new Map());
+  const exposedExperimentsRef = (0, import_react17.useRef)(/* @__PURE__ */ new Set());
+  const getBaseProps = (0, import_react17.useCallback)(() => ({
+    session_exposures: exposuresRef.current,
+    session_conversions: conversionsRef.current,
+    active_experiment_count: activeExperimentsRef.current.size
+  }), []);
+  const getStorageKey = (0, import_react17.useCallback)((experimentId) => {
+    return `balance_ab_${experimentId}`;
+  }, []);
+  const getVariant = (0, import_react17.useCallback)((experimentId) => {
+    if (typeof window === "undefined")
+      return null;
+    try {
+      const stored = localStorage.getItem(getStorageKey(experimentId));
+      return stored;
+    } catch {
+      return null;
+    }
+  }, [getStorageKey]);
+  const setVariant = (0, import_react17.useCallback)((experimentId, variant) => {
+    if (typeof window === "undefined")
+      return;
+    try {
+      localStorage.setItem(getStorageKey(experimentId), variant);
+      activeExperimentsRef.current.set(experimentId, variant);
+    } catch {
+    }
+  }, [getStorageKey]);
+  const getActiveExperiments = (0, import_react17.useCallback)(() => {
+    return new Map(activeExperimentsRef.current);
+  }, []);
+  const getStats = (0, import_react17.useCallback)(() => {
+    const exposures = exposuresRef.current;
+    const conversions = conversionsRef.current;
+    const conversionRate = exposures > 0 ? Math.round(conversions / exposures * 1e4) / 100 : 0;
+    return {
+      exposures,
+      conversions,
+      activeExperiments: activeExperimentsRef.current.size,
+      conversionRate
+    };
+  }, []);
+  const reset = (0, import_react17.useCallback)(() => {
+    exposuresRef.current = 0;
+    conversionsRef.current = 0;
+    activeExperimentsRef.current.clear();
+    exposedExperimentsRef.current.clear();
+  }, []);
+  (0, import_react17.useEffect)(() => {
+    if (typeof window === "undefined")
+      return;
+    try {
+      for (let i = 0; i < localStorage.length; i++) {
+        const key = localStorage.key(i);
+        if (key?.startsWith("balance_ab_")) {
+          const experimentId = key.replace("balance_ab_", "");
+          const variant = localStorage.getItem(key);
+          if (variant) {
+            activeExperimentsRef.current.set(experimentId, variant);
+          }
+        }
+      }
+    } catch {
+    }
+  }, []);
+  const trackExposure = (0, import_react17.useCallback)((experimentId, variant, context) => {
+    const exposureKey = `${experimentId}:${variant}`;
+    if (exposedExperimentsRef.current.has(exposureKey))
+      return;
+    exposedExperimentsRef.current.add(exposureKey);
+    exposuresRef.current += 1;
+    activeExperimentsRef.current.set(experimentId, variant);
+    track2("experiment_exposure", {
+      ...getBaseProps(),
+      experiment_id: experimentId,
+      variant,
+      is_first_exposure: true,
+      ...context
+    });
+  }, [track2, getBaseProps]);
+  const trackConversion = (0, import_react17.useCallback)((experimentId, variant, conversionData) => {
+    conversionsRef.current += 1;
+    track2("experiment_conversion", {
+      ...getBaseProps(),
+      experiment_id: experimentId,
+      variant,
+      ...conversionData
+    });
+  }, [track2, getBaseProps]);
+  const trackInteraction = (0, import_react17.useCallback)((experimentId, variant, interactionType, details) => {
+    track2("experiment_interaction", {
+      ...getBaseProps(),
+      experiment_id: experimentId,
+      variant,
+      interaction_type: interactionType,
+      ...details
+    });
+  }, [track2, getBaseProps]);
+  const enrollUser = (0, import_react17.useCallback)((experimentId, variant, source = "random") => {
+    setVariant(experimentId, variant);
+    track2("experiment_enrolled", {
+      ...getBaseProps(),
+      experiment_id: experimentId,
+      variant,
+      enrollment_source: source
+    });
+  }, [track2, getBaseProps, setVariant]);
+  const exitExperiment = (0, import_react17.useCallback)((experimentId, reason = "completed") => {
+    const variant = activeExperimentsRef.current.get(experimentId);
+    activeExperimentsRef.current.delete(experimentId);
+    track2("experiment_exit", {
+      ...getBaseProps(),
+      experiment_id: experimentId,
+      variant,
+      exit_reason: reason
+    });
+  }, [track2, getBaseProps]);
+  const trackFeatureFlag = (0, import_react17.useCallback)((flag) => {
+    track2("feature_flag_evaluated", {
+      ...getBaseProps(),
+      flag_key: flag.key,
+      flag_enabled: flag.enabled,
+      flag_variant: flag.variant,
+      flag_source: flag.source || "unknown"
+    });
+  }, [track2, getBaseProps]);
+  const trackFeatureFlagToggle = (0, import_react17.useCallback)((flagKey, newValue, previousValue) => {
+    track2("feature_flag_toggled", {
+      ...getBaseProps(),
+      flag_key: flagKey,
+      new_value: newValue,
+      previous_value: previousValue
+    });
+  }, [track2, getBaseProps]);
+  const trackGoal = (0, import_react17.useCallback)((experimentId, goalName, value, context) => {
+    const variant = activeExperimentsRef.current.get(experimentId);
+    track2("experiment_goal", {
+      ...getBaseProps(),
+      experiment_id: experimentId,
+      variant,
+      goal_name: goalName,
+      goal_value: value,
+      ...context
+    });
+  }, [track2, getBaseProps]);
+  const trackSegment = (0, import_react17.useCallback)((segmentId, segmentName, criteria) => {
+    track2("segment_assigned", {
+      ...getBaseProps(),
+      segment_id: segmentId,
+      segment_name: segmentName,
+      ...criteria
+    });
+  }, [track2, getBaseProps]);
+  return {
+    // Experiment tracking
+    trackExposure,
+    trackConversion,
+    trackInteraction,
+    enrollUser,
+    exitExperiment,
+    // Feature flags
+    trackFeatureFlag,
+    trackFeatureFlagToggle,
+    // Goals & segments
+    trackGoal,
+    trackSegment,
+    // Variant management
+    getVariant,
+    setVariant,
+    getActiveExperiments,
+    // Utilities
+    getStats,
+    reset
+  };
+}
+
+// src/react/useBalanceLive.ts
+var import_react18 = require("react");
+function useBalanceLive() {
+  const { track: track2 } = useBalance();
+  const currentStreamRef = (0, import_react18.useRef)(null);
+  const streamStartTimeRef = (0, import_react18.useRef)(null);
+  const totalWatchTimeRef = (0, import_react18.useRef)(0);
+  const messageCountRef = (0, import_react18.useRef)(0);
+  const reactionCountRef = (0, import_react18.useRef)(0);
+  const tipCountRef = (0, import_react18.useRef)(0);
+  const lastMilestoneRef = (0, import_react18.useRef)(0);
+  const watchTimeIntervalRef = (0, import_react18.useRef)(null);
+  const getCurrentWatchTime = (0, import_react18.useCallback)(() => {
+    if (!streamStartTimeRef.current)
+      return 0;
+    return Math.round((Date.now() - streamStartTimeRef.current) / 1e3);
+  }, []);
+  const getBaseProps = (0, import_react18.useCallback)(() => ({
+    current_stream_id: currentStreamRef.current,
+    session_watch_time_seconds: totalWatchTimeRef.current + getCurrentWatchTime(),
+    session_messages: messageCountRef.current,
+    session_reactions: reactionCountRef.current,
+    session_tips: tipCountRef.current
+  }), [getCurrentWatchTime]);
+  const getStats = (0, import_react18.useCallback)(() => ({
+    totalWatchTimeSeconds: totalWatchTimeRef.current + getCurrentWatchTime(),
+    messagesent: messageCountRef.current,
+    reactions: reactionCountRef.current,
+    tips: tipCountRef.current,
+    currentStreamId: currentStreamRef.current
+  }), [getCurrentWatchTime]);
+  const reset = (0, import_react18.useCallback)(() => {
+    if (watchTimeIntervalRef.current) {
+      clearInterval(watchTimeIntervalRef.current);
+      watchTimeIntervalRef.current = null;
+    }
+    currentStreamRef.current = null;
+    streamStartTimeRef.current = null;
+    totalWatchTimeRef.current = 0;
+    messageCountRef.current = 0;
+    reactionCountRef.current = 0;
+    tipCountRef.current = 0;
+    lastMilestoneRef.current = 0;
+  }, []);
+  (0, import_react18.useEffect)(() => {
+    return () => {
+      if (watchTimeIntervalRef.current) {
+        clearInterval(watchTimeIntervalRef.current);
+      }
+    };
+  }, []);
+  const joinStream = (0, import_react18.useCallback)((streamId, streamTitle, artistId, metadata) => {
+    if (currentStreamRef.current && currentStreamRef.current !== streamId) {
+      totalWatchTimeRef.current += getCurrentWatchTime();
+    }
+    currentStreamRef.current = streamId;
+    streamStartTimeRef.current = Date.now();
+    lastMilestoneRef.current = 0;
+    track2("stream_joined", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      stream_title: streamTitle,
+      artist_id: artistId,
+      ...metadata
+    });
+    if (watchTimeIntervalRef.current) {
+      clearInterval(watchTimeIntervalRef.current);
+    }
+    watchTimeIntervalRef.current = setInterval(() => {
+      const minutes = Math.floor(getCurrentWatchTime() / 60);
+      if (minutes > lastMilestoneRef.current && minutes % 5 === 0) {
+        lastMilestoneRef.current = minutes;
+        track2("viewer_milestone", {
+          ...getBaseProps(),
+          stream_id: streamId,
+          minutes_watched: minutes
+        });
+      }
+    }, 6e4);
+  }, [track2, getBaseProps, getCurrentWatchTime]);
+  const leaveStream = (0, import_react18.useCallback)((streamId, reason = "user") => {
+    const watchTime = getCurrentWatchTime();
+    totalWatchTimeRef.current += watchTime;
+    if (watchTimeIntervalRef.current) {
+      clearInterval(watchTimeIntervalRef.current);
+      watchTimeIntervalRef.current = null;
+    }
+    track2("stream_left", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      watch_time_seconds: watchTime,
+      leave_reason: reason
+    });
+    currentStreamRef.current = null;
+    streamStartTimeRef.current = null;
+  }, [track2, getBaseProps, getCurrentWatchTime]);
+  const playbackStarted = (0, import_react18.useCallback)((streamId, quality, latencyMs) => {
+    track2("stream_playback_started", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      quality,
+      latency_ms: latencyMs
+    });
+  }, [track2, getBaseProps]);
+  const buffering = (0, import_react18.useCallback)((streamId, durationMs, reason) => {
+    track2("stream_buffering", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      buffer_duration_ms: durationMs,
+      buffer_reason: reason
+    });
+  }, [track2, getBaseProps]);
+  const qualityChanged = (0, import_react18.useCallback)((streamId, previousQuality, newQuality, isAutomatic) => {
+    track2("stream_quality_changed", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      previous_quality: previousQuality,
+      new_quality: newQuality,
+      is_automatic: isAutomatic
+    });
+  }, [track2, getBaseProps]);
+  const streamError = (0, import_react18.useCallback)((streamId, errorCode, errorMessage) => {
+    track2("stream_error", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      error_code: errorCode,
+      error_message: errorMessage
+    });
+  }, [track2, getBaseProps]);
+  const sendChat = (0, import_react18.useCallback)((streamId, messageLength, hasEmoji) => {
+    messageCountRef.current += 1;
+    track2("stream_chat_sent", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      message_length: messageLength,
+      has_emoji: hasEmoji
+    });
+  }, [track2, getBaseProps]);
+  const react = (0, import_react18.useCallback)((streamId, reactionType) => {
+    reactionCountRef.current += 1;
+    track2("stream_reaction", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      reaction_type: reactionType
+    });
+  }, [track2, getBaseProps]);
+  const tip = (0, import_react18.useCallback)((streamId, amount, currency, message) => {
+    tipCountRef.current += 1;
+    track2("stream_tip", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      tip_amount: amount,
+      tip_currency: currency,
+      has_message: !!message
+    });
+  }, [track2, getBaseProps]);
+  const gift = (0, import_react18.useCallback)((streamId, giftType, recipientId, value) => {
+    track2("stream_gift", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      gift_type: giftType,
+      recipient_id: recipientId,
+      gift_value: value
+    });
+  }, [track2, getBaseProps]);
+  const pollVote = (0, import_react18.useCallback)((streamId, pollId, optionId) => {
+    track2("stream_poll_vote", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      poll_id: pollId,
+      option_id: optionId
+    });
+  }, [track2, getBaseProps]);
+  const submitQuestion = (0, import_react18.useCallback)((streamId, questionId, isAnonymous) => {
+    track2("stream_question_submitted", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      question_id: questionId,
+      is_anonymous: isAnonymous
+    });
+  }, [track2, getBaseProps]);
+  const share = (0, import_react18.useCallback)((streamId, platform) => {
+    track2("stream_shared", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      share_platform: platform
+    });
+  }, [track2, getBaseProps]);
+  const captureClip = (0, import_react18.useCallback)((streamId, clipDurationSeconds) => {
+    track2("stream_clip_captured", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      clip_duration_seconds: clipDurationSeconds
+    });
+  }, [track2, getBaseProps]);
+  const toggleFullscreen = (0, import_react18.useCallback)((streamId, isFullscreen) => {
+    track2("stream_fullscreen_toggled", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      is_fullscreen: isFullscreen
+    });
+  }, [track2, getBaseProps]);
+  const togglePiP = (0, import_react18.useCallback)((streamId, isPiP) => {
+    track2("stream_pip_toggled", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      is_pip: isPiP
+    });
+  }, [track2, getBaseProps]);
+  const volumeChanged = (0, import_react18.useCallback)((streamId, volume, isMuted) => {
+    track2("stream_volume_changed", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      volume_level: Math.round(volume * 100),
+      is_muted: isMuted
+    });
+  }, [track2, getBaseProps]);
+  const viewerMilestone = (0, import_react18.useCallback)((streamId, minutesWatched) => {
+    track2("viewer_milestone", {
+      ...getBaseProps(),
+      stream_id: streamId,
+      minutes_watched: minutesWatched
+    });
+  }, [track2, getBaseProps]);
+  return {
+    // Stream lifecycle
+    joinStream,
+    leaveStream,
+    playbackStarted,
+    buffering,
+    qualityChanged,
+    streamError,
+    // Viewer interactions
+    sendChat,
+    react,
+    tip,
+    gift,
+    pollVote,
+    submitQuestion,
+    share,
+    // Viewer controls
+    captureClip,
+    toggleFullscreen,
+    togglePiP,
+    volumeChanged,
+    viewerMilestone,
+    // Utilities
+    getStats,
+    reset
+  };
+}
+
+// src/react/useBalanceSubscription.ts
+var import_react19 = require("react");
+function useBalanceSubscription() {
+  const { track: track2, purchase: purchase2 } = useBalance();
+  const subscriptionCountRef = (0, import_react19.useRef)(0);
+  const upgradeCountRef = (0, import_react19.useRef)(0);
+  const downgradeCountRef = (0, import_react19.useRef)(0);
+  const cancellationCountRef = (0, import_react19.useRef)(0);
+  const totalRevenueRef = (0, import_react19.useRef)(0);
+  const getBaseProps = (0, import_react19.useCallback)(() => ({
+    session_subscriptions: subscriptionCountRef.current,
+    session_upgrades: upgradeCountRef.current,
+    session_cancellations: cancellationCountRef.current
+  }), []);
+  const getStats = (0, import_react19.useCallback)(() => ({
+    subscriptions: subscriptionCountRef.current,
+    upgrades: upgradeCountRef.current,
+    downgrades: downgradeCountRef.current,
+    cancellations: cancellationCountRef.current,
+    totalRevenue: totalRevenueRef.current
+  }), []);
+  const reset = (0, import_react19.useCallback)(() => {
+    subscriptionCountRef.current = 0;
+    upgradeCountRef.current = 0;
+    downgradeCountRef.current = 0;
+    cancellationCountRef.current = 0;
+    totalRevenueRef.current = 0;
+  }, []);
+  const subscribe = (0, import_react19.useCallback)((planId, price, currency, interval, metadata) => {
+    subscriptionCountRef.current += 1;
+    totalRevenueRef.current += price;
+    purchase2(price, currency, {
+      type: "subscription",
+      plan_id: planId,
+      interval
+    });
+    track2("subscription_started", {
+      ...getBaseProps(),
+      plan_id: planId,
+      price,
+      currency,
+      billing_interval: interval,
+      ...metadata
+    });
+  }, [track2, purchase2, getBaseProps]);
+  const startTrial = (0, import_react19.useCallback)((planId, trialDays, willConvertTo) => {
+    track2("trial_started", {
+      ...getBaseProps(),
+      plan_id: planId,
+      trial_days: trialDays,
+      will_convert_to: willConvertTo
+    });
+  }, [track2, getBaseProps]);
+  const trialConverted = (0, import_react19.useCallback)((planId, price, currency) => {
+    subscriptionCountRef.current += 1;
+    totalRevenueRef.current += price;
+    purchase2(price, currency, {
+      type: "trial_conversion",
+      plan_id: planId
+    });
+    track2("trial_converted", {
+      ...getBaseProps(),
+      plan_id: planId,
+      price,
+      currency
+    });
+  }, [track2, purchase2, getBaseProps]);
+  const trialExpired = (0, import_react19.useCallback)((planId, reason) => {
+    track2("trial_expired", {
+      ...getBaseProps(),
+      plan_id: planId,
+      expiry_reason: reason
+    });
+  }, [track2, getBaseProps]);
+  const upgrade = (0, import_react19.useCallback)((fromPlanId, toPlanId, priceDifference, currency) => {
+    upgradeCountRef.current += 1;
+    totalRevenueRef.current += priceDifference;
+    track2("subscription_upgraded", {
+      ...getBaseProps(),
+      from_plan_id: fromPlanId,
+      to_plan_id: toPlanId,
+      price_difference: priceDifference,
+      currency
+    });
+  }, [track2, getBaseProps]);
+  const downgrade = (0, import_react19.useCallback)((fromPlanId, toPlanId, priceDifference, currency, reason) => {
+    downgradeCountRef.current += 1;
+    track2("subscription_downgraded", {
+      ...getBaseProps(),
+      from_plan_id: fromPlanId,
+      to_plan_id: toPlanId,
+      price_difference: priceDifference,
+      currency,
+      downgrade_reason: reason
+    });
+  }, [track2, getBaseProps]);
+  const renewal = (0, import_react19.useCallback)((planId, price, currency, periodNumber) => {
+    totalRevenueRef.current += price;
+    purchase2(price, currency, {
+      type: "renewal",
+      plan_id: planId,
+      period_number: periodNumber
+    });
+    track2("subscription_renewed", {
+      ...getBaseProps(),
+      plan_id: planId,
+      price,
+      currency,
+      period_number: periodNumber
+    });
+  }, [track2, purchase2, getBaseProps]);
+  const cancelInitiated = (0, import_react19.useCallback)((planId, reason, feedback) => {
+    track2("cancellation_initiated", {
+      ...getBaseProps(),
+      plan_id: planId,
+      cancellation_reason: reason,
+      feedback: feedback?.slice(0, 500)
+    });
+  }, [track2, getBaseProps]);
+  const cancel = (0, import_react19.useCallback)((planId, reason, wasInTrial, periodsCompleted) => {
+    cancellationCountRef.current += 1;
+    track2("subscription_canceled", {
+      ...getBaseProps(),
+      plan_id: planId,
+      cancellation_reason: reason,
+      was_in_trial: wasInTrial,
+      periods_completed: periodsCompleted
+    });
+  }, [track2, getBaseProps]);
+  const pause = (0, import_react19.useCallback)((planId, pauseDurationDays, reason) => {
+    track2("subscription_paused", {
+      ...getBaseProps(),
+      plan_id: planId,
+      pause_duration_days: pauseDurationDays,
+      pause_reason: reason
+    });
+  }, [track2, getBaseProps]);
+  const resume = (0, import_react19.useCallback)((planId, pausedDays) => {
+    track2("subscription_resumed", {
+      ...getBaseProps(),
+      plan_id: planId,
+      paused_days: pausedDays
+    });
+  }, [track2, getBaseProps]);
+  const reactivate = (0, import_react19.useCallback)((planId, daysSinceCanceled, winbackOffer) => {
+    subscriptionCountRef.current += 1;
+    track2("subscription_reactivated", {
+      ...getBaseProps(),
+      plan_id: planId,
+      days_since_canceled: daysSinceCanceled,
+      winback_offer: winbackOffer
+    });
+  }, [track2, getBaseProps]);
+  const addPaymentMethod = (0, import_react19.useCallback)((methodType, isDefault) => {
+    track2("payment_method_added", {
+      ...getBaseProps(),
+      method_type: methodType,
+      is_default: isDefault
+    });
+  }, [track2, getBaseProps]);
+  const updatePaymentMethod = (0, import_react19.useCallback)((oldMethodType, newMethodType) => {
+    track2("payment_method_updated", {
+      ...getBaseProps(),
+      old_method_type: oldMethodType,
+      new_method_type: newMethodType
+    });
+  }, [track2, getBaseProps]);
+  const removePaymentMethod = (0, import_react19.useCallback)((methodType) => {
+    track2("payment_method_removed", {
+      ...getBaseProps(),
+      method_type: methodType
+    });
+  }, [track2, getBaseProps]);
+  const paymentFailed = (0, import_react19.useCallback)((planId, amount, currency, failureReason, attemptNumber) => {
+    track2("payment_failed", {
+      ...getBaseProps(),
+      plan_id: planId,
+      amount,
+      currency,
+      failure_reason: failureReason,
+      attempt_number: attemptNumber
+    });
+  }, [track2, getBaseProps]);
+  const paymentRecovered = (0, import_react19.useCallback)((planId, amount, currency, daysOverdue) => {
+    totalRevenueRef.current += amount;
+    track2("payment_recovered", {
+      ...getBaseProps(),
+      plan_id: planId,
+      amount,
+      currency,
+      days_overdue: daysOverdue
+    });
+  }, [track2, getBaseProps]);
+  const refund = (0, import_react19.useCallback)((planId, amount, currency, reason, isPartial) => {
+    totalRevenueRef.current -= amount;
+    track2("refund_issued", {
+      ...getBaseProps(),
+      plan_id: planId,
+      refund_amount: amount,
+      currency,
+      refund_reason: reason,
+      is_partial: isPartial
+    });
+  }, [track2, getBaseProps]);
+  const applyPromo = (0, import_react19.useCallback)((promoCode, discountPercent, discountAmount, currency) => {
+    track2("promo_applied", {
+      ...getBaseProps(),
+      promo_code: promoCode,
+      discount_percent: discountPercent,
+      discount_amount: discountAmount,
+      currency
+    });
+  }, [track2, getBaseProps]);
+  const giftPurchased = (0, import_react19.useCallback)((planId, price, currency, recipientType) => {
+    totalRevenueRef.current += price;
+    purchase2(price, currency, {
+      type: "gift_subscription",
+      plan_id: planId
+    });
+    track2("gift_subscription_purchased", {
+      ...getBaseProps(),
+      plan_id: planId,
+      price,
+      currency,
+      recipient_type: recipientType
+    });
+  }, [track2, purchase2, getBaseProps]);
+  const giftRedeemed = (0, import_react19.useCallback)((planId, giftCode) => {
+    subscriptionCountRef.current += 1;
+    track2("gift_subscription_redeemed", {
+      ...getBaseProps(),
+      plan_id: planId,
+      gift_code: giftCode
+    });
+  }, [track2, getBaseProps]);
+  const viewBillingPage = (0, import_react19.useCallback)(() => {
+    track2("billing_page_viewed", {
+      ...getBaseProps()
+    });
+  }, [track2, getBaseProps]);
+  const viewPricingPage = (0, import_react19.useCallback)((source) => {
+    track2("pricing_page_viewed", {
+      ...getBaseProps(),
+      source
+    });
+  }, [track2, getBaseProps]);
+  return {
+    // Subscription lifecycle
+    subscribe,
+    startTrial,
+    trialConverted,
+    trialExpired,
+    // Plan changes
+    upgrade,
+    downgrade,
+    renewal,
+    // Cancellation
+    cancelInitiated,
+    cancel,
+    pause,
+    resume,
+    reactivate,
+    // Payment methods
+    addPaymentMethod,
+    updatePaymentMethod,
+    removePaymentMethod,
+    // Payments
+    paymentFailed,
+    paymentRecovered,
+    refund,
+    // Promos & gifts
+    applyPromo,
+    giftPurchased,
+    giftRedeemed,
+    // Page views
+    viewBillingPage,
+    viewPricingPage,
+    // Utilities
+    getStats,
+    reset
+  };
+}
+
 // src/react/BalanceAnalytics.tsx
-var import_react = __toESM(require("react"));
+var import_react20 = __toESM(require("react"));
 var import_navigation = require("next/navigation");
 function BalanceAnalyticsInner() {
   const pathname = (0, import_navigation.usePathname)();
   const searchParams = (0, import_navigation.useSearchParams)();
-  const isFirstRender = (0, import_react.useRef)(true);
-  const lastTrackedPath = (0, import_react.useRef)(null);
-  (0, import_react.useEffect)(() => {
-    if (typeof window === "undefined" || !window.balance)
+  const isFirstRender = (0, import_react20.useRef)(true);
+  const lastTrackedPath = (0, import_react20.useRef)(null);
+  const balance = useBalanceOptional();
+  (0, import_react20.useEffect)(() => {
+    if (typeof window === "undefined")
+      return;
+    const pageTracker = balance?.page ?? window.balance?.page;
+    if (!pageTracker && !window.balance)
       return;
     const currentPath = pathname + (searchParams?.toString() || "");
     if (lastTrackedPath.current === currentPath) {
@@ -81,16 +2783,22 @@ function BalanceAnalyticsInner() {
     const url = window.location.href;
     const title = document.title;
     lastTrackedPath.current = currentPath;
-    window.balance.page({ url, title });
-  }, [pathname, searchParams]);
+    if (balance?.page) {
+      balance.page({ url, title });
+    } else if (window.balance?.page) {
+      window.balance.page({ url, title });
+    } else if (window.balance) {
+      window.balance("page", { url, title });
+    }
+  }, [pathname, searchParams, balance]);
   return null;
 }
 function BalanceAnalytics() {
-  return /* @__PURE__ */ import_react.default.createElement(import_react.Suspense, { fallback: null }, /* @__PURE__ */ import_react.default.createElement(BalanceAnalyticsInner, null));
+  return /* @__PURE__ */ import_react20.default.createElement(import_react20.Suspense, { fallback: null }, /* @__PURE__ */ import_react20.default.createElement(BalanceAnalyticsInner, null));
 }
 
 // src/react/useBalanceIdentify.ts
-var import_react2 = require("react");
+var import_react21 = require("react");
 
 // src/storage/StorageManager.ts
 var DEFAULT_PREFIX = "balance_";
@@ -314,10 +3022,10 @@ function checkAnalyticsConsent() {
   }
 }
 function useBalanceIdentify() {
-  const pollIntervalRef = (0, import_react2.useRef)(null);
-  const hasProcessedPending = (0, import_react2.useRef)(false);
+  const pollIntervalRef = (0, import_react21.useRef)(null);
+  const hasProcessedPending = (0, import_react21.useRef)(false);
   const storageManager = typeof window !== "undefined" ? getStorageManager() : null;
-  const getPendingIdentify = (0, import_react2.useCallback)(() => {
+  const getPendingIdentify = (0, import_react21.useCallback)(() => {
     if (!storageManager)
       return null;
     const pending = storageManager.getJSON(PENDING_IDENTIFY_KEY);
@@ -329,7 +3037,7 @@ function useBalanceIdentify() {
     }
     return pending;
   }, [storageManager]);
-  const setPendingIdentify = (0, import_react2.useCallback)((email, traits) => {
+  const setPendingIdentify = (0, import_react21.useCallback)((email, traits) => {
     if (!storageManager)
       return;
     storageManager.setJSON(PENDING_IDENTIFY_KEY, {
@@ -338,12 +3046,12 @@ function useBalanceIdentify() {
       timestamp: Date.now()
     });
   }, [storageManager]);
-  const clearPendingIdentify = (0, import_react2.useCallback)(() => {
+  const clearPendingIdentify = (0, import_react21.useCallback)(() => {
     if (!storageManager)
       return;
     storageManager.removeItem(PENDING_IDENTIFY_KEY);
   }, [storageManager]);
-  const identify2 = (0, import_react2.useCallback)((email, traits) => {
+  const identify2 = (0, import_react21.useCallback)((email, traits) => {
     const hasConsent2 = checkAnalyticsConsent();
     if (!hasConsent2) {
       console.log("[useBalanceIdentify] Skipping identify - user declined analytics consent");
@@ -362,7 +3070,7 @@ function useBalanceIdentify() {
     setPendingIdentify(email, traits);
     return false;
   }, [storageManager, clearPendingIdentify, setPendingIdentify]);
-  const processPendingIdentify = (0, import_react2.useCallback)(() => {
+  const processPendingIdentify = (0, import_react21.useCallback)(() => {
     if (hasProcessedPending.current)
       return;
     const pending = getPendingIdentify();
@@ -385,7 +3093,7 @@ function useBalanceIdentify() {
       hasProcessedPending.current = true;
     }
   }, [getPendingIdentify, clearPendingIdentify, storageManager]);
-  (0, import_react2.useEffect)(() => {
+  (0, import_react21.useEffect)(() => {
     processPendingIdentify();
     const pending = getPendingIdentify();
     if (pending && !hasProcessedPending.current) {
@@ -419,156 +3127,6 @@ function useBalanceIdentify() {
   };
 }
 
-// src/react/GTMProvider.tsx
-var import_react4 = __toESM(require("react"));
-var import_script = __toESM(require("next/script"));
-
-// src/react/useGTMConsent.ts
-var import_react3 = require("react");
-function useGTMConsent(options = {}) {
-  const { pollInterval = 1e3, debug = false } = options;
-  const lastConsentRef = (0, import_react3.useRef)("");
-  const log = (0, import_react3.useCallback)(
-    (...args) => {
-      if (debug) {
-        console.log("[useGTMConsent]", ...args);
-      }
-    },
-    [debug]
-  );
-  const mapPixelConsentToGTM = (0, import_react3.useCallback)(() => {
-    if (typeof window === "undefined" || !window.balance) {
-      return {
-        ad_storage: "denied",
-        ad_user_data: "denied",
-        ad_personalization: "denied",
-        analytics_storage: "denied"
-      };
-    }
-    const hasAnalytics = window.balance.hasConsent("analytics");
-    const hasMarketing = window.balance.hasConsent("marketing");
-    const analyticsState = hasAnalytics ? "granted" : "denied";
-    const marketingState = hasMarketing ? "granted" : "denied";
-    return {
-      analytics_storage: analyticsState,
-      ad_storage: marketingState,
-      ad_user_data: marketingState,
-      ad_personalization: marketingState
-    };
-  }, []);
-  const updateGTMConsent = (0, import_react3.useCallback)(
-    (consentConfig) => {
-      if (typeof window === "undefined")
-        return;
-      window.dataLayer = window.dataLayer || [];
-      if (typeof window.gtag !== "function") {
-        window.gtag = function gtag(...args) {
-          window.dataLayer.push(args);
-        };
-      }
-      window.gtag("consent", "update", consentConfig);
-      log("Pushed consent update to GTM:", consentConfig);
-    },
-    [log]
-  );
-  const syncConsent = (0, import_react3.useCallback)(() => {
-    const currentConsent = mapPixelConsentToGTM();
-    const consentKey = JSON.stringify(currentConsent);
-    if (consentKey !== lastConsentRef.current) {
-      lastConsentRef.current = consentKey;
-      updateGTMConsent(currentConsent);
-    }
-  }, [mapPixelConsentToGTM, updateGTMConsent]);
-  (0, import_react3.useEffect)(() => {
-    if (typeof window === "undefined")
-      return;
-    syncConsent();
-    const intervalId = setInterval(syncConsent, pollInterval);
-    const handleStorageChange = (e) => {
-      if (e.key === "balance_consent") {
-        log("Consent changed in another tab, syncing...");
-        syncConsent();
-      }
-    };
-    window.addEventListener("storage", handleStorageChange);
-    return () => {
-      clearInterval(intervalId);
-      window.removeEventListener("storage", handleStorageChange);
-    };
-  }, [syncConsent, pollInterval, log]);
-  return {
-    /**
-     * Manually trigger a consent sync
-     */
-    syncConsent,
-    /**
-     * Get current consent config
-     */
-    getConsentConfig: mapPixelConsentToGTM
-  };
-}
-
-// src/types/gtm.ts
-var DEFAULT_GTM_CONSENT = {
-  ad_storage: "denied",
-  ad_user_data: "denied",
-  ad_personalization: "denied",
-  analytics_storage: "denied"
-};
-
-// src/react/GTMProvider.tsx
-function GTMProvider({ gtmId, children, debug = false }) {
-  const resolvedGtmId = gtmId || process.env.NEXT_PUBLIC_GTM_ID;
-  useGTMConsent({ debug });
-  if (!resolvedGtmId) {
-    if (debug) {
-      console.log("[GTMProvider] No GTM ID configured, skipping GTM initialization");
-    }
-    return /* @__PURE__ */ import_react4.default.createElement(import_react4.default.Fragment, null, children);
-  }
-  const consentJson = JSON.stringify(DEFAULT_GTM_CONSENT);
-  const consentScript = `
-    window.dataLayer = window.dataLayer || [];
-    function gtag(){dataLayer.push(arguments);}
-    window.gtag = gtag;
-    gtag('consent', 'default', ${consentJson});
-    gtag('set', 'wait_for_update', 500);
-    ${debug ? "console.log('[GTM] Default consent initialized (denied)');" : ""}
-  `;
-  return /* @__PURE__ */ import_react4.default.createElement(import_react4.default.Fragment, null, /* @__PURE__ */ import_react4.default.createElement(
-    import_script.default,
-    {
-      id: "gtm-consent-default",
-      strategy: "beforeInteractive",
-      dangerouslySetInnerHTML: { __html: consentScript }
-    }
-  ), /* @__PURE__ */ import_react4.default.createElement(
-    import_script.default,
-    {
-      id: "gtm-script",
-      strategy: "afterInteractive",
-      dangerouslySetInnerHTML: {
-        __html: `
-            (function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
-            new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
-            j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
-            'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
-            })(window,document,'script','dataLayer','${resolvedGtmId}');
-          `
-      }
-    }
-  ), /* @__PURE__ */ import_react4.default.createElement("noscript", null, /* @__PURE__ */ import_react4.default.createElement(
-    "iframe",
-    {
-      src: `https://www.googletagmanager.com/ns.html?id=${resolvedGtmId}`,
-      height: "0",
-      width: "0",
-      style: { display: "none", visibility: "hidden" },
-      title: "GTM"
-    }
-  )), children);
-}
-
 // src/index.esm.ts
 var track = (eventName, properties) => {
   if (typeof window === "undefined")