@hifilabs/pixel 0.7.1 → 0.9.0

package/dist/index.mjs

@@ -1,13 +1,1244 @@
 'use client';
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 
+// src/react/ArtistOS/useResolvedConfig.ts
+import { useMemo } from "react";
+function getEnvVar(key) {
+  if (typeof window === "undefined") {
+    return process.env[key];
+  }
+  return window.__ENV__?.[key] ?? process.env[key];
+}
+function parseEnvBool(value) {
+  return value === "true" || value === "1";
+}
+function useResolvedConfig(props) {
+  return useMemo(() => {
+    const artistId = props.artistId ?? getEnvVar("NEXT_PUBLIC_ARTIST_ID");
+    const gtmId = props.gtmId ?? getEnvVar("NEXT_PUBLIC_GTM_ID");
+    const endpoint = props.endpoint ?? getEnvVar("NEXT_PUBLIC_PIXEL_ENDPOINT");
+    const scriptUrl = props.scriptUrl ?? DEFAULT_SCRIPT_URL;
+    const projectId = props.projectId ?? getEnvVar("NEXT_PUBLIC_PROJECT_ID");
+    const debug = props.debug ?? parseEnvBool(getEnvVar("NEXT_PUBLIC_PIXEL_DEBUG"));
+    const disabled = props.disabled ?? false;
+    const useEmulator = props.useEmulator ?? parseEnvBool(getEnvVar("NEXT_PUBLIC_USE_EMULATOR"));
+    const consent = {
+      ...DEFAULT_CONSENT_CONFIG,
+      ...props.consent
+    };
+    return {
+      artistId,
+      gtmId,
+      endpoint,
+      scriptUrl,
+      debug,
+      disabled,
+      useEmulator,
+      projectId,
+      consent
+    };
+  }, [
+    props.artistId,
+    props.gtmId,
+    props.endpoint,
+    props.scriptUrl,
+    props.projectId,
+    props.debug,
+    props.disabled,
+    props.useEmulator,
+    props.consent
+  ]);
+}
+var DEFAULT_SCRIPT_URL, DEFAULT_CONSENT_CONFIG;
+var init_useResolvedConfig = __esm({
+  "src/react/ArtistOS/useResolvedConfig.ts"() {
+    "use client";
+    DEFAULT_SCRIPT_URL = "/scripts/index.js";
+    DEFAULT_CONSENT_CONFIG = {
+      mode: "built-in",
+      showBanner: true,
+      bannerDelay: 2e3,
+      bannerPosition: "bottom",
+      showManageButton: true,
+      storageKey: "artistos_consent",
+      expiryDays: 365
+    };
+  }
+});
+
+// src/react/ArtistOS/useBuiltInConsent.ts
+import { useState, useEffect, useCallback, useMemo as useMemo2 } from "react";
+function getStoredConsent(storageKey) {
+  if (typeof window === "undefined")
+    return null;
+  try {
+    const stored = localStorage.getItem(storageKey);
+    if (!stored)
+      return null;
+    const parsed = JSON.parse(stored);
+    if (Date.now() > parsed.expiresAt) {
+      localStorage.removeItem(storageKey);
+      return null;
+    }
+    return parsed.consent;
+  } catch {
+    return null;
+  }
+}
+function saveStoredConsent(storageKey, consent, expiryDays) {
+  if (typeof window === "undefined")
+    return;
+  try {
+    const stored = {
+      consent,
+      expiresAt: Date.now() + expiryDays * 24 * 60 * 60 * 1e3
+    };
+    localStorage.setItem(storageKey, JSON.stringify(stored));
+  } catch {
+  }
+}
+function createDefaultConsent() {
+  return {
+    analytics: false,
+    marketing: false,
+    personalization: false,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function createAcceptAllConsent() {
+  return {
+    analytics: true,
+    marketing: true,
+    personalization: true,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function useBuiltInConsent(config) {
+  const { storageKey, expiryDays, showBanner: shouldShowBanner, bannerDelay } = config;
+  const [consent, setConsent2] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [hasConsented, setHasConsented] = useState(false);
+  const [showBanner, setShowBanner] = useState(false);
+  const [showDialog, setShowDialog] = useState(false);
+  useEffect(() => {
+    const stored = getStoredConsent(storageKey);
+    if (stored) {
+      setConsent2(stored);
+      setHasConsented(true);
+    }
+    setLoading(false);
+  }, [storageKey]);
+  useEffect(() => {
+    if (loading)
+      return;
+    if (hasConsented)
+      return;
+    if (!shouldShowBanner)
+      return;
+    if (config.mode !== "built-in")
+      return;
+    const timer = setTimeout(() => {
+      setShowBanner(true);
+    }, bannerDelay);
+    return () => clearTimeout(timer);
+  }, [loading, hasConsented, shouldShowBanner, bannerDelay, config.mode]);
+  useEffect(() => {
+    if (!consent)
+      return;
+    if (typeof window === "undefined")
+      return;
+    if (window.balance?.setConsent) {
+      window.balance.setConsent(consent);
+    }
+  }, [consent]);
+  const updateConsent = useCallback(
+    (prefs) => {
+      setConsent2(prefs);
+      setHasConsented(true);
+      setShowBanner(false);
+      setShowDialog(false);
+      saveStoredConsent(storageKey, prefs, expiryDays);
+    },
+    [storageKey, expiryDays]
+  );
+  const acceptAll = useCallback(() => {
+    updateConsent(createAcceptAllConsent());
+  }, [updateConsent]);
+  const declineAll = useCallback(() => {
+    updateConsent(createDefaultConsent());
+  }, [updateConsent]);
+  const hasConsentType = useCallback(
+    (type) => {
+      return consent?.[type] ?? false;
+    },
+    [consent]
+  );
+  return useMemo2(
+    () => ({
+      consent,
+      loading,
+      hasConsented,
+      updateConsent,
+      acceptAll,
+      declineAll,
+      hasConsent: hasConsentType,
+      showBanner,
+      setShowBanner,
+      showDialog,
+      setShowDialog
+    }),
+    [
+      consent,
+      loading,
+      hasConsented,
+      updateConsent,
+      acceptAll,
+      declineAll,
+      hasConsentType,
+      showBanner,
+      showDialog
+    ]
+  );
+}
+var init_useBuiltInConsent = __esm({
+  "src/react/ArtistOS/useBuiltInConsent.ts"() {
+    "use client";
+  }
+});
+
+// src/react/ArtistOS/ConsentBanner.tsx
+import React from "react";
+function ConsentBanner({
+  onAccept,
+  onDecline,
+  onManageClick,
+  showManageButton = true,
+  position = "bottom",
+  className
+}) {
+  const [isVisible, setIsVisible] = React.useState(true);
+  const handleAccept = () => {
+    setIsVisible(false);
+    onAccept();
+  };
+  const handleDecline = () => {
+    setIsVisible(false);
+    onDecline();
+  };
+  const handleClose = () => {
+    setIsVisible(false);
+  };
+  if (!isVisible) {
+    return null;
+  }
+  return /* @__PURE__ */ React.createElement("div", { style: styles.wrapper(position), className }, /* @__PURE__ */ React.createElement("div", { style: styles.container }, /* @__PURE__ */ React.createElement("div", { style: styles.content }, /* @__PURE__ */ React.createElement("p", { style: styles.message }, /* @__PURE__ */ React.createElement("span", { style: styles.strong }, "Privacy Notice:"), ' We use cookies to track pageviews and send you email notifications about new releases. By clicking "Accept All", you consent to our use of cookies and data processing.'), /* @__PURE__ */ React.createElement("div", { style: styles.actions }, showManageButton && onManageClick && /* @__PURE__ */ React.createElement(
+    "button",
+    {
+      onClick: onManageClick,
+      style: { ...styles.button, ...styles.buttonGhost },
+      onMouseEnter: (e) => {
+        e.currentTarget.style.color = "#000000";
+      },
+      onMouseLeave: (e) => {
+        e.currentTarget.style.color = "#666666";
+      }
+    },
+    "Manage Preferences"
+  ), /* @__PURE__ */ React.createElement(
+    "button",
+    {
+      onClick: handleDecline,
+      style: { ...styles.button, ...styles.buttonOutline },
+      onMouseEnter: (e) => {
+        e.currentTarget.style.backgroundColor = "#f5f5f5";
+      },
+      onMouseLeave: (e) => {
+        e.currentTarget.style.backgroundColor = "#ffffff";
+      }
+    },
+    "Decline"
+  ), /* @__PURE__ */ React.createElement(
+    "button",
+    {
+      onClick: handleAccept,
+      style: { ...styles.button, ...styles.buttonPrimary },
+      onMouseEnter: (e) => {
+        e.currentTarget.style.backgroundColor = "#333333";
+      },
+      onMouseLeave: (e) => {
+        e.currentTarget.style.backgroundColor = "#000000";
+      }
+    },
+    "Accept All"
+  ), /* @__PURE__ */ React.createElement(
+    "button",
+    {
+      onClick: handleClose,
+      style: styles.closeButton,
+      "aria-label": "Close banner",
+      onMouseEnter: (e) => {
+        e.currentTarget.style.backgroundColor = "#f5f5f5";
+      },
+      onMouseLeave: (e) => {
+        e.currentTarget.style.backgroundColor = "transparent";
+      }
+    },
+    /* @__PURE__ */ React.createElement(CloseIcon, null)
+  )))));
+}
+var styles, CloseIcon;
+var init_ConsentBanner = __esm({
+  "src/react/ArtistOS/ConsentBanner.tsx"() {
+    "use client";
+    styles = {
+      wrapper: (position) => ({
+        position: "fixed",
+        [position]: 0,
+        left: 0,
+        right: 0,
+        zIndex: 999999,
+        backgroundColor: "#ffffff",
+        borderTop: position === "bottom" ? "2px solid #000000" : "none",
+        borderBottom: position === "top" ? "2px solid #000000" : "none",
+        boxShadow: position === "bottom" ? "0 -4px 6px rgba(0,0,0,0.1)" : "0 4px 6px rgba(0,0,0,0.1)",
+        fontFamily: "system-ui, -apple-system, sans-serif"
+      }),
+      container: {
+        maxWidth: "1280px",
+        margin: "0 auto",
+        padding: "16px 24px",
+        display: "flex",
+        flexDirection: "column",
+        gap: "16px"
+      },
+      content: {
+        display: "flex",
+        flexDirection: "row",
+        alignItems: "center",
+        justifyContent: "space-between",
+        flexWrap: "wrap",
+        gap: "16px"
+      },
+      message: {
+        flex: 1,
+        minWidth: "280px",
+        fontSize: "14px",
+        lineHeight: "1.5",
+        color: "#000000",
+        margin: 0
+      },
+      strong: {
+        fontWeight: 700
+      },
+      actions: {
+        display: "flex",
+        flexDirection: "row",
+        gap: "8px",
+        alignItems: "center",
+        flexShrink: 0
+      },
+      button: {
+        padding: "8px 16px",
+        fontSize: "14px",
+        fontWeight: 500,
+        cursor: "pointer",
+        border: "2px solid #000000",
+        borderRadius: "2px",
+        transition: "all 0.15s ease",
+        whiteSpace: "nowrap"
+      },
+      buttonPrimary: {
+        backgroundColor: "#000000",
+        color: "#ffffff"
+      },
+      buttonOutline: {
+        backgroundColor: "#ffffff",
+        color: "#000000"
+      },
+      buttonGhost: {
+        backgroundColor: "transparent",
+        border: "none",
+        color: "#666666",
+        textDecoration: "underline"
+      },
+      closeButton: {
+        padding: "4px",
+        background: "none",
+        border: "2px solid #000000",
+        cursor: "pointer",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        borderRadius: "2px",
+        marginLeft: "8px"
+      }
+    };
+    CloseIcon = () => /* @__PURE__ */ React.createElement(
+      "svg",
+      {
+        width: "16",
+        height: "16",
+        viewBox: "0 0 24 24",
+        fill: "none",
+        stroke: "currentColor",
+        strokeWidth: "2",
+        strokeLinecap: "round",
+        strokeLinejoin: "round"
+      },
+      /* @__PURE__ */ React.createElement("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+      /* @__PURE__ */ React.createElement("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+    );
+  }
+});
+
+// src/react/ArtistOS/ConsentDialog.tsx
+import React2, { useEffect as useEffect2, useRef } from "react";
+function ConsentDialog({
+  open,
+  onOpenChange,
+  initialConsent,
+  onSave
+}) {
+  const dialogRef = useRef(null);
+  const [analytics, setAnalytics] = React2.useState(initialConsent?.analytics ?? false);
+  const [marketing, setMarketing] = React2.useState(initialConsent?.marketing ?? false);
+  const [personalization, setPersonalization] = React2.useState(
+    initialConsent?.personalization ?? false
+  );
+  useEffect2(() => {
+    if (initialConsent) {
+      setAnalytics(initialConsent.analytics);
+      setMarketing(initialConsent.marketing);
+      setPersonalization(initialConsent.personalization);
+    }
+  }, [initialConsent]);
+  useEffect2(() => {
+    const handleEscape = (e) => {
+      if (e.key === "Escape" && open) {
+        onOpenChange(false);
+      }
+    };
+    document.addEventListener("keydown", handleEscape);
+    return () => document.removeEventListener("keydown", handleEscape);
+  }, [open, onOpenChange]);
+  useEffect2(() => {
+    if (open) {
+      document.body.style.overflow = "hidden";
+      dialogRef.current?.focus();
+    } else {
+      document.body.style.overflow = "";
+    }
+    return () => {
+      document.body.style.overflow = "";
+    };
+  }, [open]);
+  const handleSave = () => {
+    const preferences = {
+      analytics,
+      marketing,
+      personalization,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    onSave?.(preferences);
+    onOpenChange(false);
+  };
+  const handleAcceptAll = () => {
+    setAnalytics(true);
+    setMarketing(true);
+    setPersonalization(true);
+    const preferences = {
+      analytics: true,
+      marketing: true,
+      personalization: true,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    onSave?.(preferences);
+    onOpenChange(false);
+  };
+  const handleDeclineAll = () => {
+    setAnalytics(false);
+    setMarketing(false);
+    setPersonalization(false);
+    const preferences = {
+      analytics: false,
+      marketing: false,
+      personalization: false,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    onSave?.(preferences);
+    onOpenChange(false);
+  };
+  const handleOverlayClick = (e) => {
+    if (e.target === e.currentTarget) {
+      onOpenChange(false);
+    }
+  };
+  if (!open) {
+    return null;
+  }
+  return /* @__PURE__ */ React2.createElement("div", { style: styles2.overlay, onClick: handleOverlayClick, role: "presentation" }, /* @__PURE__ */ React2.createElement(
+    "div",
+    {
+      ref: dialogRef,
+      style: styles2.dialog,
+      role: "dialog",
+      "aria-modal": "true",
+      "aria-labelledby": "consent-dialog-title",
+      tabIndex: -1
+    },
+    /* @__PURE__ */ React2.createElement("div", { style: styles2.header }, /* @__PURE__ */ React2.createElement("h2", { id: "consent-dialog-title", style: styles2.title }, "Privacy Preferences"), /* @__PURE__ */ React2.createElement("p", { style: styles2.description }, "Manage your data and privacy settings. You can update these preferences at any time.")),
+    /* @__PURE__ */ React2.createElement("div", { style: styles2.content }, /* @__PURE__ */ React2.createElement("div", { style: styles2.consentItem }, /* @__PURE__ */ React2.createElement(
+      "input",
+      {
+        type: "checkbox",
+        id: "consent-analytics",
+        checked: analytics,
+        onChange: (e) => setAnalytics(e.target.checked),
+        style: styles2.checkbox
+      }
+    ), /* @__PURE__ */ React2.createElement("div", { style: styles2.labelWrapper }, /* @__PURE__ */ React2.createElement("label", { htmlFor: "consent-analytics", style: styles2.label }, CONSENT_OPTIONS[0].label), /* @__PURE__ */ React2.createElement("p", { style: styles2.labelDescription }, CONSENT_OPTIONS[0].description))), /* @__PURE__ */ React2.createElement("div", { style: styles2.consentItem }, /* @__PURE__ */ React2.createElement(
+      "input",
+      {
+        type: "checkbox",
+        id: "consent-marketing",
+        checked: marketing,
+        onChange: (e) => setMarketing(e.target.checked),
+        style: styles2.checkbox
+      }
+    ), /* @__PURE__ */ React2.createElement("div", { style: styles2.labelWrapper }, /* @__PURE__ */ React2.createElement("label", { htmlFor: "consent-marketing", style: styles2.label }, CONSENT_OPTIONS[1].label), /* @__PURE__ */ React2.createElement("p", { style: styles2.labelDescription }, CONSENT_OPTIONS[1].description))), /* @__PURE__ */ React2.createElement("div", { style: styles2.consentItem }, /* @__PURE__ */ React2.createElement(
+      "input",
+      {
+        type: "checkbox",
+        id: "consent-personalization",
+        checked: personalization,
+        onChange: (e) => setPersonalization(e.target.checked),
+        style: styles2.checkbox
+      }
+    ), /* @__PURE__ */ React2.createElement("div", { style: styles2.labelWrapper }, /* @__PURE__ */ React2.createElement("label", { htmlFor: "consent-personalization", style: styles2.label }, CONSENT_OPTIONS[2].label), /* @__PURE__ */ React2.createElement("p", { style: styles2.labelDescription }, CONSENT_OPTIONS[2].description)))),
+    /* @__PURE__ */ React2.createElement("div", { style: styles2.footer }, /* @__PURE__ */ React2.createElement(
+      "button",
+      {
+        onClick: handleDeclineAll,
+        style: { ...styles2.button, ...styles2.buttonGhost },
+        onMouseEnter: (e) => {
+          e.currentTarget.style.backgroundColor = "#f5f5f5";
+        },
+        onMouseLeave: (e) => {
+          e.currentTarget.style.backgroundColor = "transparent";
+        }
+      },
+      "Decline All"
+    ), /* @__PURE__ */ React2.createElement(
+      "button",
+      {
+        onClick: handleAcceptAll,
+        style: { ...styles2.button, ...styles2.buttonOutline },
+        onMouseEnter: (e) => {
+          e.currentTarget.style.backgroundColor = "#f5f5f5";
+        },
+        onMouseLeave: (e) => {
+          e.currentTarget.style.backgroundColor = "#ffffff";
+        }
+      },
+      "Accept All"
+    ), /* @__PURE__ */ React2.createElement(
+      "button",
+      {
+        onClick: handleSave,
+        style: { ...styles2.button, ...styles2.buttonPrimary },
+        onMouseEnter: (e) => {
+          e.currentTarget.style.backgroundColor = "#333333";
+        },
+        onMouseLeave: (e) => {
+          e.currentTarget.style.backgroundColor = "#000000";
+        }
+      },
+      "Save Preferences"
+    ))
+  ));
+}
+var styles2, CONSENT_OPTIONS;
+var init_ConsentDialog = __esm({
+  "src/react/ArtistOS/ConsentDialog.tsx"() {
+    "use client";
+    styles2 = {
+      overlay: {
+        position: "fixed",
+        inset: 0,
+        backgroundColor: "rgba(0, 0, 0, 0.5)",
+        zIndex: 9999999,
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        padding: "16px"
+      },
+      dialog: {
+        backgroundColor: "#ffffff",
+        border: "2px solid #000000",
+        borderRadius: "4px",
+        maxWidth: "500px",
+        width: "100%",
+        maxHeight: "90vh",
+        overflow: "auto",
+        fontFamily: "system-ui, -apple-system, sans-serif",
+        boxShadow: "4px 4px 0 #000000"
+      },
+      header: {
+        padding: "24px 24px 0"
+      },
+      title: {
+        fontSize: "24px",
+        fontWeight: 700,
+        margin: "0 0 8px",
+        color: "#000000"
+      },
+      description: {
+        fontSize: "14px",
+        color: "#666666",
+        margin: 0,
+        lineHeight: "1.5"
+      },
+      content: {
+        padding: "24px"
+      },
+      consentItem: {
+        display: "flex",
+        alignItems: "flex-start",
+        gap: "12px",
+        marginBottom: "20px"
+      },
+      checkbox: {
+        width: "20px",
+        height: "20px",
+        marginTop: "2px",
+        cursor: "pointer",
+        accentColor: "#000000"
+      },
+      labelWrapper: {
+        flex: 1
+      },
+      label: {
+        fontSize: "16px",
+        fontWeight: 600,
+        color: "#000000",
+        display: "block",
+        marginBottom: "4px",
+        cursor: "pointer"
+      },
+      labelDescription: {
+        fontSize: "14px",
+        color: "#666666",
+        lineHeight: "1.5",
+        margin: 0
+      },
+      footer: {
+        display: "flex",
+        justifyContent: "flex-end",
+        gap: "8px",
+        padding: "16px 24px",
+        borderTop: "1px solid #e5e5e5"
+      },
+      button: {
+        padding: "8px 16px",
+        fontSize: "14px",
+        fontWeight: 500,
+        cursor: "pointer",
+        border: "2px solid #000000",
+        borderRadius: "2px",
+        transition: "all 0.15s ease"
+      },
+      buttonPrimary: {
+        backgroundColor: "#000000",
+        color: "#ffffff"
+      },
+      buttonOutline: {
+        backgroundColor: "#ffffff",
+        color: "#000000"
+      },
+      buttonGhost: {
+        backgroundColor: "transparent",
+        border: "none",
+        color: "#666666"
+      }
+    };
+    CONSENT_OPTIONS = [
+      {
+        id: "analytics",
+        label: "Analytics & Performance",
+        description: "Track pageviews, clicks, and engagement to help us improve your experience and understand how you interact with our content."
+      },
+      {
+        id: "marketing",
+        label: "Marketing & Notifications",
+        description: "Receive email notifications about new releases, exclusive content, and updates. You can unsubscribe at any time."
+      },
+      {
+        id: "personalization",
+        label: "Personalization",
+        description: "Customize your experience based on your preferences and behavior. This helps us show you relevant content and recommendations."
+      }
+    ];
+  }
+});
+
+// src/react/ArtistOS/useC15tConsent.ts
+import { useState as useState2, useCallback as useCallback2, useEffect as useEffect3, useMemo as useMemo3, useRef as useRef2 } from "react";
+function toBalanceConsent(c15tConsents) {
+  return {
+    analytics: c15tConsents?.measurement ?? false,
+    marketing: c15tConsents?.marketing ?? false,
+    personalization: c15tConsents?.experience ?? false,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function fromBalanceConsent(balanceConsent) {
+  return {
+    measurement: balanceConsent.analytics,
+    marketing: balanceConsent.marketing,
+    experience: balanceConsent.personalization
+  };
+}
+function useC15tConsent(_config) {
+  console.warn(
+    '[ArtistOS] useC15tConsent is deprecated. Use ArtistOS with consent={{ mode: "c15t" }} instead.'
+  );
+  return {
+    consent: null,
+    loading: false,
+    hasConsented: false,
+    updateConsent: () => {
+    },
+    acceptAll: () => {
+    },
+    declineAll: () => {
+    },
+    hasConsent: () => false,
+    showBanner: false,
+    setShowBanner: () => {
+    },
+    showDialog: false,
+    setShowDialog: () => {
+    }
+  };
+}
+function useC15tConsentState(c15tManager, config) {
+  const [showBanner, setShowBanner] = useState2(false);
+  const [showDialog, setShowDialog] = useState2(false);
+  const [loading, setLoading] = useState2(true);
+  const mountedRef = useRef2(true);
+  useEffect3(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const consent = useMemo3(() => {
+    if (!c15tManager?.consents)
+      return null;
+    return toBalanceConsent(c15tManager.consents);
+  }, [c15tManager?.consents]);
+  const hasConsented = c15tManager?.hasConsented?.() ?? false;
+  useEffect3(() => {
+    if (config.mode !== "c15t")
+      return;
+    if (!config.showBanner)
+      return;
+    let initTimer = null;
+    let bannerTimer = null;
+    initTimer = setTimeout(() => {
+      if (!mountedRef.current)
+        return;
+      setLoading(false);
+      if (!c15tManager?.hasConsented?.()) {
+        bannerTimer = setTimeout(() => {
+          if (mountedRef.current) {
+            setShowBanner(true);
+          }
+        }, config.bannerDelay);
+      }
+    }, 100);
+    return () => {
+      if (initTimer)
+        clearTimeout(initTimer);
+      if (bannerTimer)
+        clearTimeout(bannerTimer);
+    };
+  }, [c15tManager, config.mode, config.showBanner, config.bannerDelay]);
+  const updateConsent = useCallback2(
+    (prefs) => {
+      if (!c15tManager)
+        return;
+      c15tManager.setConsent("measurement", prefs.analytics);
+      c15tManager.setConsent("marketing", prefs.marketing);
+      c15tManager.setConsent("experience", prefs.personalization);
+      c15tManager.saveConsents("custom");
+      setShowBanner(false);
+      setShowDialog(false);
+    },
+    [c15tManager]
+  );
+  const acceptAll = useCallback2(() => {
+    if (!c15tManager)
+      return;
+    c15tManager.acceptAll();
+    c15tManager.saveConsents("accept_all");
+    setShowBanner(false);
+    setShowDialog(false);
+  }, [c15tManager]);
+  const declineAll = useCallback2(() => {
+    if (!c15tManager)
+      return;
+    c15tManager.rejectAll();
+    c15tManager.saveConsents("reject_all");
+    setShowBanner(false);
+    setShowDialog(false);
+  }, [c15tManager]);
+  const hasConsent2 = useCallback2(
+    (type) => {
+      if (!c15tManager)
+        return false;
+      const c15tCategory = BALANCE_TO_C15T_MAP[type];
+      return c15tManager.hasConsentFor?.(c15tCategory) ?? false;
+    },
+    [c15tManager]
+  );
+  return {
+    consent,
+    loading,
+    hasConsented,
+    updateConsent,
+    acceptAll,
+    declineAll,
+    hasConsent: hasConsent2,
+    showBanner,
+    setShowBanner,
+    showDialog,
+    setShowDialog
+  };
+}
+var C15T_TO_BALANCE_MAP, BALANCE_TO_C15T_MAP;
+var init_useC15tConsent = __esm({
+  "src/react/ArtistOS/useC15tConsent.ts"() {
+    "use client";
+    C15T_TO_BALANCE_MAP = {
+      measurement: "analytics",
+      marketing: "marketing",
+      experience: "personalization"
+    };
+    BALANCE_TO_C15T_MAP = {
+      analytics: "measurement",
+      marketing: "marketing",
+      personalization: "experience"
+    };
+  }
+});
+
+// src/react/ArtistOS/ArtistOSWithC15t.tsx
+var ArtistOSWithC15t_exports = {};
+__export(ArtistOSWithC15t_exports, {
+  ArtistOSWithC15t: () => ArtistOSWithC15t,
+  default: () => ArtistOSWithC15t_default
+});
+import React3, { useEffect as useEffect4, useMemo as useMemo4, useState as useState3, useRef as useRef3 } from "react";
+function loadC15tModule() {
+  if (c15tModuleCache.status === "loaded") {
+    return Promise.resolve();
+  }
+  if (c15tLoadPromise) {
+    return c15tLoadPromise;
+  }
+  c15tLoadPromise = import("@c15t/react").then((mod) => {
+    c15tModuleCache = {
+      status: "loaded",
+      module: {
+        ConsentManagerProvider: mod.ConsentManagerProvider,
+        useConsentManager: mod.useConsentManager
+      },
+      error: null
+    };
+  }).catch((err) => {
+    c15tModuleCache = {
+      status: "error",
+      module: null,
+      error: err
+    };
+    console.error(
+      "[ArtistOS] Failed to load @c15t/react. Install it with: npm install @c15t/react",
+      err
+    );
+  });
+  return c15tLoadPromise;
+}
+function useC15tModule() {
+  const [state, setState] = useState3(c15tModuleCache);
+  const mountedRef = useRef3(true);
+  useEffect4(() => {
+    mountedRef.current = true;
+    if (c15tModuleCache.status !== "loading") {
+      setState(c15tModuleCache);
+      return;
+    }
+    loadC15tModule().then(() => {
+      if (mountedRef.current) {
+        setState(c15tModuleCache);
+      }
+    });
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  return state;
+}
+function ArtistOSC15tInner({ config, children, useConsentManager }) {
+  const c15tManager = useConsentManager();
+  const consentState = useC15tConsentState(c15tManager, config.consent);
+  useGTMConsentSync(config, consentState);
+  const contextValue = useMemo4(
+    () => ({
+      config,
+      consentState
+    }),
+    [config, consentState]
+  );
+  useEffect4(() => {
+    if (config.debug) {
+      console.log("[ArtistOS] c15t mode initialized:", {
+        artistId: config.artistId,
+        gtmId: config.gtmId,
+        hasConsented: consentState.hasConsented
+      });
+    }
+  }, [config.debug, config.artistId, config.gtmId, consentState.hasConsented]);
+  useEffect4(() => {
+    if (!consentState.consent)
+      return;
+    if (typeof window === "undefined")
+      return;
+    const balance = window.balance;
+    if (!balance?.setConsent)
+      return;
+    balance.setConsent({
+      analytics: consentState.consent.analytics,
+      marketing: consentState.consent.marketing,
+      personalization: consentState.consent.personalization,
+      timestamp: consentState.consent.timestamp
+    });
+    if (config.debug) {
+      console.log("[ArtistOS] Synced c15t consent to Balance pixel:", consentState.consent);
+    }
+  }, [consentState.consent, config.debug]);
+  return /* @__PURE__ */ React3.createElement(ArtistOSContext.Provider, { value: contextValue }, /* @__PURE__ */ React3.createElement(PixelScriptLoader, { config }), /* @__PURE__ */ React3.createElement(GTMScriptLoader, { config }), /* @__PURE__ */ React3.createElement(ConsentUIManager, { config, consentState }), children);
+}
+function ArtistOSWithC15t({
+  config,
+  children
+}) {
+  const c15tState = useC15tModule();
+  if (c15tState.status === "loading") {
+    return null;
+  }
+  if (c15tState.status === "error" || !c15tState.module) {
+    if (config.debug) {
+      console.warn(
+        "[ArtistOS] c15t mode requested but @c15t/react not available.",
+        "Falling back to built-in consent."
+      );
+    }
+    return /* @__PURE__ */ React3.createElement(ArtistOSWithBuiltIn, { config }, children);
+  }
+  const { ConsentManagerProvider, useConsentManager } = c15tState.module;
+  const c15tOptions = {
+    mode: "offline",
+    // Client-side only, no server calls
+    ignoreGeoLocation: true,
+    // Don't auto-detect region
+    consentCategories: ["measurement", "marketing", "experience"],
+    storageConfig: {
+      storageKey: config.consent.storageKey || "c15t_consent",
+      defaultExpiryDays: config.consent.expiryDays || 365
+    },
+    react: {
+      noStyle: true
+      // We use ArtistOS UI, not c15t UI
+    }
+  };
+  return /* @__PURE__ */ React3.createElement(ConsentManagerProvider, { options: c15tOptions }, /* @__PURE__ */ React3.createElement(ArtistOSC15tInner, { config, useConsentManager }, children));
+}
+var c15tModuleCache, c15tLoadPromise, ArtistOSWithC15t_default;
+var init_ArtistOSWithC15t = __esm({
+  "src/react/ArtistOS/ArtistOSWithC15t.tsx"() {
+    "use client";
+    init_ArtistOS();
+    init_useC15tConsent();
+    c15tModuleCache = {
+      status: "loading",
+      module: null,
+      error: null
+    };
+    c15tLoadPromise = null;
+    ArtistOSWithC15t_default = ArtistOSWithC15t;
+  }
+});
+
+// src/react/ArtistOS/ArtistOS.tsx
+import React4, { createContext, useContext, useEffect as useEffect5, useMemo as useMemo5 } from "react";
+import Script from "next/script";
+function useArtistOS() {
+  const context = useContext(ArtistOSContext);
+  if (!context) {
+    throw new Error("useArtistOS must be used within <ArtistOS />");
+  }
+  return context;
+}
+function useArtistOSOptional() {
+  return useContext(ArtistOSContext);
+}
+function PixelScriptLoader({ config }) {
+  const { artistId, scriptUrl, endpoint, useEmulator, debug, projectId, disabled } = config;
+  if (disabled || !artistId) {
+    if (debug && !artistId) {
+      console.warn(
+        "[ArtistOS] No artistId provided. Set NEXT_PUBLIC_ARTIST_ID or pass artistId prop."
+      );
+    }
+    return null;
+  }
+  return /* @__PURE__ */ React4.createElement(
+    Script,
+    {
+      src: scriptUrl,
+      "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: () => {
+        if (debug) {
+          console.log("[ArtistOS] Pixel script loaded for artist:", artistId);
+        }
+      },
+      onError: (e) => {
+        console.error("[ArtistOS] Failed to load pixel script:", e);
+      }
+    }
+  );
+}
+function GTMScriptLoader({ config }) {
+  const { gtmId, debug, disabled } = config;
+  if (disabled || !gtmId) {
+    return null;
+  }
+  return /* @__PURE__ */ React4.createElement(React4.Fragment, null, /* @__PURE__ */ React4.createElement(
+    Script,
+    {
+      id: "gtm-init",
+      strategy: "beforeInteractive",
+      dangerouslySetInnerHTML: {
+        __html: `
+            window.dataLayer = window.dataLayer || [];
+            function gtag(){dataLayer.push(arguments);}
+            gtag('consent', 'default', {
+              'ad_storage': 'denied',
+              'ad_user_data': 'denied',
+              'ad_personalization': 'denied',
+              'analytics_storage': 'denied'
+            });
+          `
+      }
+    }
+  ), /* @__PURE__ */ React4.createElement(
+    Script,
+    {
+      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','${gtmId}');
+          `
+      },
+      onLoad: () => {
+        if (debug) {
+          console.log("[ArtistOS] GTM loaded:", gtmId);
+        }
+      }
+    }
+  ));
+}
+function ConsentUIManager({
+  config,
+  consentState
+}) {
+  const { consent: consentConfig, disabled } = config;
+  const {
+    consent,
+    showBanner,
+    setShowBanner,
+    showDialog,
+    setShowDialog,
+    acceptAll,
+    declineAll,
+    updateConsent
+  } = consentState;
+  if (disabled || consentConfig.mode === "disabled" || consentConfig.mode === "external") {
+    return null;
+  }
+  if (!consentConfig.showBanner) {
+    return null;
+  }
+  return /* @__PURE__ */ React4.createElement(React4.Fragment, null, showBanner && /* @__PURE__ */ React4.createElement(
+    ConsentBanner,
+    {
+      onAccept: acceptAll,
+      onDecline: declineAll,
+      onManageClick: () => {
+        setShowBanner(false);
+        setShowDialog(true);
+      },
+      showManageButton: consentConfig.showManageButton,
+      position: consentConfig.bannerPosition
+    }
+  ), /* @__PURE__ */ React4.createElement(
+    ConsentDialog,
+    {
+      open: showDialog,
+      onOpenChange: setShowDialog,
+      initialConsent: consent,
+      onSave: updateConsent
+    }
+  ));
+}
+function useGTMConsentSync(config, consentState) {
+  const { gtmId, disabled } = config;
+  const { consent } = consentState;
+  useEffect5(() => {
+    if (disabled || !gtmId || !consent)
+      return;
+    if (typeof window === "undefined")
+      return;
+    const gtag = window.gtag;
+    if (typeof gtag !== "function")
+      return;
+    gtag("consent", "update", {
+      ad_storage: consent.marketing ? "granted" : "denied",
+      ad_user_data: consent.marketing ? "granted" : "denied",
+      ad_personalization: consent.personalization ? "granted" : "denied",
+      analytics_storage: consent.analytics ? "granted" : "denied"
+    });
+  }, [gtmId, disabled, consent]);
+}
+function ArtistOSWithBuiltIn({
+  config,
+  children
+}) {
+  const consentState = useBuiltInConsent(config.consent);
+  useGTMConsentSync(config, consentState);
+  const contextValue = useMemo5(
+    () => ({
+      config,
+      consentState
+    }),
+    [config, consentState]
+  );
+  useEffect5(() => {
+    if (config.debug) {
+      console.log("[ArtistOS] Built-in mode initialized:", {
+        artistId: config.artistId,
+        gtmId: config.gtmId,
+        endpoint: config.endpoint,
+        consentMode: config.consent.mode
+      });
+    }
+  }, [config]);
+  return /* @__PURE__ */ React4.createElement(ArtistOSContext.Provider, { value: contextValue }, /* @__PURE__ */ React4.createElement(PixelScriptLoader, { config }), /* @__PURE__ */ React4.createElement(GTMScriptLoader, { config }), /* @__PURE__ */ React4.createElement(ConsentUIManager, { config, consentState }), children);
+}
+function ArtistOSCore({
+  config,
+  children
+}) {
+  const consentState = useBuiltInConsent(config.consent);
+  useGTMConsentSync(config, consentState);
+  const contextValue = useMemo5(
+    () => ({
+      config,
+      consentState
+    }),
+    [config, consentState]
+  );
+  useEffect5(() => {
+    if (config.debug) {
+      console.log("[ArtistOS] Core mode initialized (no consent UI):", {
+        artistId: config.artistId,
+        consentMode: config.consent.mode
+      });
+    }
+  }, [config]);
+  return /* @__PURE__ */ React4.createElement(ArtistOSContext.Provider, { value: contextValue }, /* @__PURE__ */ React4.createElement(PixelScriptLoader, { config }), /* @__PURE__ */ React4.createElement(GTMScriptLoader, { config }), children);
+}
+function ArtistOS(props) {
+  const config = useResolvedConfig(props);
+  useEffect5(() => {
+    if (config.debug) {
+      console.log("[ArtistOS] Mode:", config.consent.mode);
+    }
+  }, [config.debug, config.consent.mode]);
+  if (config.disabled) {
+    return null;
+  }
+  switch (config.consent.mode) {
+    case "c15t":
+      return /* @__PURE__ */ React4.createElement(React4.Suspense, { fallback: null }, /* @__PURE__ */ React4.createElement(LazyArtistOSWithC15t, { config }, props.children));
+    case "external":
+    case "disabled":
+      return /* @__PURE__ */ React4.createElement(ArtistOSCore, { config }, props.children);
+    case "built-in":
+    default:
+      return /* @__PURE__ */ React4.createElement(ArtistOSWithBuiltIn, { config }, props.children);
+  }
+}
+var ArtistOSContext, LazyArtistOSWithC15t;
+var init_ArtistOS = __esm({
+  "src/react/ArtistOS/ArtistOS.tsx"() {
+    "use client";
+    init_useResolvedConfig();
+    init_useBuiltInConsent();
+    init_ConsentBanner();
+    init_ConsentDialog();
+    ArtistOSContext = createContext(null);
+    LazyArtistOSWithC15t = React4.lazy(
+      () => Promise.resolve().then(() => (init_ArtistOSWithC15t(), ArtistOSWithC15t_exports)).then((mod) => ({ default: mod.ArtistOSWithC15t }))
+    );
+  }
+});
+
+// src/react/ArtistOS/index.ts
+init_ArtistOS();
+init_ArtistOSWithC15t();
+init_ConsentBanner();
+init_ConsentDialog();
+init_useResolvedConfig();
+init_useBuiltInConsent();
+init_useC15tConsent();
+
 // src/react/BalanceContext.ts
-import { createContext } from "react";
+import { createContext as createContext2 } from "react";
 var warnNoProvider = (method) => {
   if (true) {
     console.warn(
@@ -38,23 +1269,23 @@ var defaultContextValue = {
   endpoint: void 0,
   debug: false
 };
-var BalanceContext = createContext(defaultContextValue);
+var BalanceContext = createContext2(defaultContextValue);
 BalanceContext.displayName = "BalanceContext";
 
 // src/react/BalanceProvider.tsx
-import React3, { useState, useEffect as useEffect2, useCallback as useCallback2, useMemo } from "react";
-import Script2 from "next/script";
+import React7, { useState as useState4, useEffect as useEffect7, useCallback as useCallback4, useMemo as useMemo6 } from "react";
+import Script3 from "next/script";
 
 // src/react/GTMProvider.tsx
-import React2 from "react";
-import Script from "next/script";
+import React6 from "react";
+import Script2 from "next/script";
 
 // src/react/useGTMConsent.ts
-import { useEffect, useRef, useCallback } from "react";
+import { useEffect as useEffect6, useRef as useRef4, useCallback as useCallback3 } from "react";
 function useGTMConsent(options = {}) {
   const { pollInterval = 1e3, debug = false, enabled = true } = options;
-  const lastConsentRef = useRef("");
-  const log = useCallback(
+  const lastConsentRef = useRef4("");
+  const log = useCallback3(
     (...args) => {
       if (debug) {
         console.log("[useGTMConsent]", ...args);
@@ -62,7 +1293,7 @@ function useGTMConsent(options = {}) {
     },
     [debug]
   );
-  const mapPixelConsentToGTM = useCallback(() => {
+  const mapPixelConsentToGTM = useCallback3(() => {
     if (typeof window === "undefined" || !window.balance) {
       return {
         ad_storage: "denied",
@@ -82,7 +1313,7 @@ function useGTMConsent(options = {}) {
       ad_personalization: marketingState
     };
   }, []);
-  const updateGTMConsent = useCallback(
+  const updateGTMConsent = useCallback3(
     (consentConfig) => {
       if (typeof window === "undefined")
         return;
@@ -97,7 +1328,7 @@ function useGTMConsent(options = {}) {
     },
     [log]
   );
-  const syncConsent = useCallback(() => {
+  const syncConsent = useCallback3(() => {
     const currentConsent = mapPixelConsentToGTM();
     const consentKey = JSON.stringify(currentConsent);
     if (consentKey !== lastConsentRef.current) {
@@ -105,7 +1336,7 @@ function useGTMConsent(options = {}) {
       updateGTMConsent(currentConsent);
     }
   }, [mapPixelConsentToGTM, updateGTMConsent]);
-  useEffect(() => {
+  useEffect6(() => {
     if (typeof window === "undefined" || !enabled)
       return;
     syncConsent();
@@ -150,7 +1381,7 @@ function GTMProvider({ gtmId, children, debug = false }) {
     if (debug) {
       console.log("[GTMProvider] No GTM ID configured, skipping GTM initialization");
     }
-    return /* @__PURE__ */ React2.createElement(React2.Fragment, null, children);
+    return /* @__PURE__ */ React6.createElement(React6.Fragment, null, children);
   }
   const consentJson = JSON.stringify(DEFAULT_GTM_CONSENT);
   const consentScript = `
@@ -161,15 +1392,15 @@ function GTMProvider({ gtmId, children, debug = false }) {
     gtag('set', 'wait_for_update', 500);
     ${debug ? "console.log('[GTM] Default consent initialized (denied)');" : ""}
   `;
-  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(
-    Script,
+  return /* @__PURE__ */ React6.createElement(React6.Fragment, null, /* @__PURE__ */ React6.createElement(
+    Script2,
     {
       id: "gtm-consent-default",
       strategy: "beforeInteractive",
       dangerouslySetInnerHTML: { __html: consentScript }
     }
-  ), /* @__PURE__ */ React2.createElement(
-    Script,
+  ), /* @__PURE__ */ React6.createElement(
+    Script2,
     {
       id: "gtm-script",
       strategy: "afterInteractive",
@@ -183,7 +1414,7 @@ function GTMProvider({ gtmId, children, debug = false }) {
           `
       }
     }
-  ), /* @__PURE__ */ React2.createElement("noscript", null, /* @__PURE__ */ React2.createElement(
+  ), /* @__PURE__ */ React6.createElement("noscript", null, /* @__PURE__ */ React6.createElement(
     "iframe",
     {
       src: `https://www.googletagmanager.com/ns.html?id=${resolvedGtmId}`,
@@ -196,7 +1427,7 @@ function GTMProvider({ gtmId, children, debug = false }) {
 }
 
 // src/react/BalanceProvider.tsx
-var DEFAULT_SCRIPT_URL = "https://cdn.hifilabs.co/balance-pixel.js";
+var DEFAULT_SCRIPT_URL2 = "https://cdn.hifilabs.co/balance-pixel.js";
 function ensureGlobalStub() {
   if (typeof window === "undefined")
     return;
@@ -214,13 +1445,17 @@ function BalanceProvider({
   scriptUrl,
   endpoint,
   useEmulator = false,
+  exclude,
+  trackFileDownloads = false,
+  hashRouting = false,
+  integrity,
   children
 }) {
-  const [isReady, setIsReady] = useState(false);
-  const [isError, setIsError] = useState(false);
-  const [error, setError] = useState(null);
-  const [shouldLoadScript, setShouldLoadScript] = useState(false);
-  useEffect2(() => {
+  const [isReady, setIsReady] = useState4(false);
+  const [isError, setIsError] = useState4(false);
+  const [error, setError] = useState4(null);
+  const [shouldLoadScript, setShouldLoadScript] = useState4(false);
+  useEffect7(() => {
     ensureGlobalStub();
     const existingScript = document.querySelector(
       'script[src*="balance-pixel"], script[data-artist-id]'
@@ -234,7 +1469,7 @@ function BalanceProvider({
     }
     setShouldLoadScript(true);
   }, [debug]);
-  const track2 = useCallback2((event, properties) => {
+  const track2 = useCallback4((event, properties) => {
     if (typeof window === "undefined")
       return;
     if (window.balance?.track) {
@@ -244,7 +1479,7 @@ function BalanceProvider({
       window.balance("track", event, properties || {});
     }
   }, []);
-  const identify2 = useCallback2((email, traits) => {
+  const identify2 = useCallback4((email, traits) => {
     if (typeof window === "undefined")
       return;
     if (window.balance?.identify) {
@@ -254,7 +1489,7 @@ function BalanceProvider({
       window.balance("identify", email, traits || {});
     }
   }, []);
-  const page2 = useCallback2((options) => {
+  const page2 = useCallback4((options) => {
     if (typeof window === "undefined")
       return;
     if (window.balance?.page) {
@@ -264,7 +1499,7 @@ function BalanceProvider({
       window.balance("page", options || {});
     }
   }, []);
-  const purchase2 = useCallback2((amount, currency, properties) => {
+  const purchase2 = useCallback4((amount, currency, properties) => {
     if (typeof window === "undefined")
       return;
     if (window.balance?.purchase) {
@@ -274,22 +1509,22 @@ function BalanceProvider({
       window.balance("purchase", amount, currency || "USD", properties || {});
     }
   }, []);
-  const getSessionId2 = useCallback2(() => {
+  const getSessionId2 = useCallback4(() => {
     if (typeof window === "undefined")
       return null;
     return window.balance?.getSessionId?.() ?? null;
   }, []);
-  const getFanIdHash2 = useCallback2(() => {
+  const getFanIdHash2 = useCallback4(() => {
     if (typeof window === "undefined")
       return null;
     return window.balance?.getFanIdHash?.() ?? null;
   }, []);
-  const getAttribution2 = useCallback2(() => {
+  const getAttribution2 = useCallback4(() => {
     if (typeof window === "undefined")
       return {};
     return window.balance?.getAttribution?.() ?? {};
   }, []);
-  const setConsent2 = useCallback2((preferences) => {
+  const setConsent2 = useCallback4((preferences) => {
     if (typeof window === "undefined")
       return;
     if (window.balance?.setConsent) {
@@ -299,17 +1534,17 @@ function BalanceProvider({
       window.balance("setConsent", preferences);
     }
   }, []);
-  const getConsent2 = useCallback2(() => {
+  const getConsent2 = useCallback4(() => {
     if (typeof window === "undefined")
       return null;
     return window.balance?.getConsent?.() ?? null;
   }, []);
-  const hasConsent2 = useCallback2((type) => {
+  const hasConsent2 = useCallback4((type) => {
     if (typeof window === "undefined")
       return false;
     return window.balance?.hasConsent?.(type) ?? false;
   }, []);
-  const contextValue = useMemo(() => ({
+  const contextValue = useMemo6(() => ({
     // Tracking methods (always usable via queue)
     track: track2,
     identify: identify2,
@@ -350,27 +1585,27 @@ function BalanceProvider({
     endpoint,
     debug
   ]);
-  const handleScriptLoad = useCallback2(() => {
+  const handleScriptLoad = useCallback4(() => {
     if (debug) {
       console.log("[BalanceProvider] Pixel script loaded");
     }
     setIsReady(true);
   }, [debug]);
-  const handleScriptError = useCallback2((e) => {
+  const handleScriptError = useCallback4((e) => {
     console.error("[BalanceProvider] Failed to load pixel script:", e);
     setIsError(true);
     setError(e);
   }, []);
-  const resolvedScriptUrl = scriptUrl ?? DEFAULT_SCRIPT_URL;
-  useEffect2(() => {
+  const resolvedScriptUrl = scriptUrl ?? DEFAULT_SCRIPT_URL2;
+  useEffect7(() => {
     if (debug && !scriptUrl) {
       console.warn(
         '[BalanceProvider] Using default CDN URL. For production, consider hosting the pixel script locally:\n1. Copy index.js from artist-os-distro/apps/web/public/scripts/\n2. Place it in your public/scripts/index.js\n3. Set scriptUrl="/scripts/index.js"\n\nThis avoids external dependencies and CSP issues.'
       );
     }
   }, [debug, scriptUrl]);
-  const content = /* @__PURE__ */ React3.createElement(BalanceContext.Provider, { value: contextValue }, shouldLoadScript && /* @__PURE__ */ React3.createElement(
-    Script2,
+  const content = /* @__PURE__ */ React7.createElement(BalanceContext.Provider, { value: contextValue }, shouldLoadScript && /* @__PURE__ */ React7.createElement(
+    Script3,
     {
       src: resolvedScriptUrl,
       "data-artist-id": artistId,
@@ -378,21 +1613,26 @@ function BalanceProvider({
       "data-endpoint": endpoint,
       "data-emulator": useEmulator ? "true" : void 0,
       "data-debug": debug ? "true" : void 0,
+      "data-exclude-pages": exclude?.join(",") || void 0,
+      "data-track-file-downloads": trackFileDownloads ? "true" : void 0,
+      "data-hash-routing": hashRouting ? "true" : void 0,
+      integrity,
+      crossOrigin: integrity ? "anonymous" : void 0,
       strategy: "afterInteractive",
       onLoad: handleScriptLoad,
       onError: handleScriptError
     }
   ), children);
   if (gtmId) {
-    return /* @__PURE__ */ React3.createElement(GTMProvider, { gtmId, debug }, content);
+    return /* @__PURE__ */ React7.createElement(GTMProvider, { gtmId, debug }, content);
   }
   return content;
 }
 
 // src/react/useBalance.ts
-import { useContext } from "react";
+import { useContext as useContext2 } from "react";
 function useBalance() {
-  const context = useContext(BalanceContext);
+  const context = useContext2(BalanceContext);
   if (!context.artistId) {
     throw new Error(
       '[useBalance] must be used within a BalanceProvider. Wrap your app with <BalanceProvider artistId="..."> or use useBalanceOptional() instead.'
@@ -401,7 +1641,7 @@ function useBalance() {
   return context;
 }
 function useBalanceOptional() {
-  const context = useContext(BalanceContext);
+  const context = useContext2(BalanceContext);
   if (!context.artistId) {
     return null;
   }
@@ -409,10 +1649,10 @@ function useBalanceOptional() {
 }
 
 // src/react/useBalanceConsent.ts
-import { useCallback as useCallback3 } from "react";
+import { useCallback as useCallback5 } from "react";
 function useBalanceConsent() {
   const { setConsent: setConsent2, getConsent: getConsent2, hasConsent: hasConsent2 } = useBalance();
-  const acceptAll = useCallback3(() => {
+  const acceptAll = useCallback5(() => {
     setConsent2({
       analytics: true,
       marketing: true,
@@ -420,7 +1660,7 @@ function useBalanceConsent() {
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
   }, [setConsent2]);
-  const declineAll = useCallback3(() => {
+  const declineAll = useCallback5(() => {
     setConsent2({
       analytics: false,
       marketing: false,
@@ -428,7 +1668,7 @@ function useBalanceConsent() {
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
   }, [setConsent2]);
-  const acceptAnalyticsOnly = useCallback3(() => {
+  const acceptAnalyticsOnly = useCallback5(() => {
     setConsent2({
       analytics: true,
       marketing: false,
@@ -447,21 +1687,21 @@ function useBalanceConsent() {
 }
 
 // src/react/useBalanceReady.ts
-import { useContext as useContext2 } from "react";
+import { useContext as useContext3 } from "react";
 function useBalanceReady() {
-  const context = useContext2(BalanceContext);
+  const context = useContext3(BalanceContext);
   return context.isReady;
 }
 
 // src/react/usePageviewTracking.ts
-import { useEffect as useEffect3, useRef as useRef2 } from "react";
+import { useEffect as useEffect8, useRef as useRef5 } from "react";
 import { usePathname } from "next/navigation";
 function usePageviewTracking(options) {
   const { page: page2 } = useBalance();
   const pathname = usePathname();
-  const isFirstRender = useRef2(true);
-  const previousPathRef = useRef2(null);
-  useEffect3(() => {
+  const isFirstRender = useRef5(true);
+  const previousPathRef = useRef5(null);
+  useEffect8(() => {
     if (isFirstRender.current) {
       isFirstRender.current = false;
       previousPathRef.current = pathname;
@@ -483,10 +1723,10 @@ function usePageviewTracking(options) {
 }
 
 // src/react/useBalanceEcommerce.ts
-import { useCallback as useCallback4 } from "react";
+import { useCallback as useCallback6 } from "react";
 function useBalanceEcommerce() {
   const { track: track2, purchase: purchase2 } = useBalance();
-  const formatProduct = useCallback4((product, quantity) => ({
+  const formatProduct = useCallback6((product, quantity) => ({
     item_id: product.id,
     item_name: product.name,
     price: product.price,
@@ -495,66 +1735,66 @@ function useBalanceEcommerce() {
     item_brand: product.brand,
     quantity: quantity ?? product.quantity ?? 1
   }), []);
-  const formatProducts = useCallback4(
+  const formatProducts = useCallback6(
     (products) => products.map((p, index) => ({
       ...formatProduct(p),
       index
     })),
     [formatProduct]
   );
-  const calculateValue = useCallback4(
+  const calculateValue = useCallback6(
     (items) => items.reduce((sum, item) => sum + item.price * (item.quantity || 1), 0),
     []
   );
-  const viewProduct = useCallback4((product) => {
+  const viewProduct = useCallback6((product) => {
     track2("view_item", {
       currency: "USD",
       value: product.price,
       items: [formatProduct(product)]
     });
   }, [track2, formatProduct]);
-  const viewProductList = useCallback4((listName, products) => {
+  const viewProductList = useCallback6((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 = useCallback4((product, listName) => {
+  const selectProduct = useCallback6((product, listName) => {
     track2("select_item", {
       item_list_name: listName,
       items: [formatProduct(product)]
     });
   }, [track2, formatProduct]);
-  const addToCart = useCallback4((product, quantity = 1) => {
+  const addToCart = useCallback6((product, quantity = 1) => {
     track2("add_to_cart", {
       currency: "USD",
       value: product.price * quantity,
       items: [formatProduct(product, quantity)]
     });
   }, [track2, formatProduct]);
-  const removeFromCart = useCallback4((product, quantity = 1) => {
+  const removeFromCart = useCallback6((product, quantity = 1) => {
     track2("remove_from_cart", {
       currency: "USD",
       value: product.price * quantity,
       items: [formatProduct(product, quantity)]
     });
   }, [track2, formatProduct]);
-  const viewCart = useCallback4((items, cartTotal) => {
+  const viewCart = useCallback6((items, cartTotal) => {
     track2("view_cart", {
       currency: "USD",
       value: cartTotal,
       items: formatProducts(items)
     });
   }, [track2, formatProducts]);
-  const beginCheckout = useCallback4((items, total, currency = "USD") => {
+  const beginCheckout = useCallback6((items, total, currency = "USD") => {
     track2("begin_checkout", {
       currency,
       value: total,
       items: formatProducts(items)
     });
   }, [track2, formatProducts]);
-  const addShippingInfo = useCallback4((shippingTier, items) => {
+  const addShippingInfo = useCallback6((shippingTier, items) => {
     track2("add_shipping_info", {
       currency: "USD",
       value: calculateValue(items),
@@ -562,7 +1802,7 @@ function useBalanceEcommerce() {
       items: formatProducts(items)
     });
   }, [track2, formatProducts, calculateValue]);
-  const addPaymentInfo = useCallback4((paymentType, items) => {
+  const addPaymentInfo = useCallback6((paymentType, items) => {
     track2("add_payment_info", {
       currency: "USD",
       value: calculateValue(items),
@@ -570,7 +1810,7 @@ function useBalanceEcommerce() {
       items: formatProducts(items)
     });
   }, [track2, formatProducts, calculateValue]);
-  const completePurchase = useCallback4((orderId, total, items, options = {}) => {
+  const completePurchase = useCallback6((orderId, total, items, options = {}) => {
     const { currency = "USD", tax, shipping, coupon } = options;
     purchase2(total, currency, {
       order_id: orderId,
@@ -580,7 +1820,7 @@ function useBalanceEcommerce() {
       items: formatProducts(items)
     });
   }, [purchase2, formatProducts]);
-  const refund = useCallback4((orderId, amount, items) => {
+  const refund = useCallback6((orderId, amount, items) => {
     track2("refund", {
       currency: "USD",
       transaction_id: orderId,
@@ -608,15 +1848,15 @@ function useBalanceEcommerce() {
 }
 
 // src/react/useBalanceMedia.ts
-import { useCallback as useCallback5, useRef as useRef3 } from "react";
+import { useCallback as useCallback7, useRef as useRef6 } from "react";
 function useBalanceMedia() {
   const { track: track2 } = useBalance();
-  const playStartRef = useRef3(null);
-  const totalListenTimeRef = useRef3(0);
-  const milestonesTrackedRef = useRef3(/* @__PURE__ */ new Set());
-  const currentMediaIdRef = useRef3(null);
-  const isPlayingRef = useRef3(false);
-  const formatMedia = useCallback5((media) => ({
+  const playStartRef = useRef6(null);
+  const totalListenTimeRef = useRef6(0);
+  const milestonesTrackedRef = useRef6(/* @__PURE__ */ new Set());
+  const currentMediaIdRef = useRef6(null);
+  const isPlayingRef = useRef6(false);
+  const formatMedia = useCallback7((media) => ({
     media_id: media.mediaId,
     title: media.title,
     duration: media.duration,
@@ -627,21 +1867,21 @@ function useBalanceMedia() {
     playlist: media.playlist,
     playlist_position: media.playlistPosition
   }), []);
-  const getListenDuration = useCallback5(() => {
+  const getListenDuration = useCallback7(() => {
     let duration = totalListenTimeRef.current;
     if (isPlayingRef.current && playStartRef.current) {
       duration += (Date.now() - playStartRef.current) / 1e3;
     }
     return Math.round(duration * 100) / 100;
   }, []);
-  const reset = useCallback5(() => {
+  const reset = useCallback7(() => {
     playStartRef.current = null;
     totalListenTimeRef.current = 0;
     milestonesTrackedRef.current.clear();
     currentMediaIdRef.current = null;
     isPlayingRef.current = false;
   }, []);
-  const play = useCallback5((media) => {
+  const play = useCallback7((media) => {
     if (currentMediaIdRef.current !== media.mediaId) {
       reset();
       currentMediaIdRef.current = media.mediaId;
@@ -653,7 +1893,7 @@ function useBalanceMedia() {
       session_listen_time: totalListenTimeRef.current
     });
   }, [track2, formatMedia, reset]);
-  const pause = useCallback5((media, currentTime) => {
+  const pause = useCallback7((media, currentTime) => {
     if (playStartRef.current && isPlayingRef.current) {
       totalListenTimeRef.current += (Date.now() - playStartRef.current) / 1e3;
     }
@@ -667,7 +1907,7 @@ function useBalanceMedia() {
       session_listen_time: totalListenTimeRef.current
     });
   }, [track2, formatMedia]);
-  const complete = useCallback5((media) => {
+  const complete = useCallback7((media) => {
     if (playStartRef.current && isPlayingRef.current) {
       totalListenTimeRef.current += (Date.now() - playStartRef.current) / 1e3;
     }
@@ -678,7 +1918,7 @@ function useBalanceMedia() {
     });
     reset();
   }, [track2, formatMedia, reset]);
-  const seek = useCallback5((media, fromTime, toTime) => {
+  const seek = useCallback7((media, fromTime, toTime) => {
     track2("media_seek", {
       ...formatMedia(media),
       from_time: fromTime,
@@ -687,7 +1927,7 @@ function useBalanceMedia() {
       seek_direction: toTime > fromTime ? "forward" : "backward"
     });
   }, [track2, formatMedia]);
-  const trackProgress = useCallback5((media, currentTime) => {
+  const trackProgress = useCallback7((media, currentTime) => {
     if (media.duration <= 0)
       return;
     const percentPlayed = currentTime / media.duration * 100;
@@ -704,28 +1944,28 @@ function useBalanceMedia() {
       }
     });
   }, [track2, formatMedia, getListenDuration]);
-  const buffer = useCallback5((media, currentTime) => {
+  const buffer = useCallback7((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 = useCallback5((media, fromQuality, toQuality) => {
+  const qualityChange = useCallback7((media, fromQuality, toQuality) => {
     track2("media_quality_change", {
       ...formatMedia(media),
       from_quality: fromQuality,
       to_quality: toQuality
     });
   }, [track2, formatMedia]);
-  const volumeChange = useCallback5((media, volume, muted) => {
+  const volumeChange = useCallback7((media, volume, muted) => {
     track2("media_volume_change", {
       ...formatMedia(media),
       volume: Math.round(volume * 100),
       muted
     });
   }, [track2, formatMedia]);
-  const speedChange = useCallback5((media, speed) => {
+  const speedChange = useCallback7((media, speed) => {
     track2("media_speed_change", {
       ...formatMedia(media),
       playback_speed: speed
@@ -751,30 +1991,30 @@ function useBalanceMedia() {
 }
 
 // src/react/useBalanceEngagement.ts
-import { useCallback as useCallback6, useRef as useRef4, useEffect as useEffect4 } from "react";
+import { useCallback as useCallback8, useRef as useRef7, useEffect as useEffect9 } from "react";
 function useBalanceEngagement(contentId, contentTitle) {
   const { track: track2 } = useBalance();
-  const scrollMilestonesRef = useRef4(/* @__PURE__ */ new Set());
-  const pageLoadTimeRef = useRef4(null);
-  const isTrackingTimeRef = useRef4(false);
-  const timeIntervalsRef = useRef4([30, 60, 120, 300]);
-  const timeTrackedRef = useRef4(/* @__PURE__ */ new Set());
-  const getBaseProps = useCallback6(() => ({
+  const scrollMilestonesRef = useRef7(/* @__PURE__ */ new Set());
+  const pageLoadTimeRef = useRef7(null);
+  const isTrackingTimeRef = useRef7(false);
+  const timeIntervalsRef = useRef7([30, 60, 120, 300]);
+  const timeTrackedRef = useRef7(/* @__PURE__ */ new Set());
+  const getBaseProps = useCallback8(() => ({
     content_id: contentId,
     content_title: contentTitle
   }), [contentId, contentTitle]);
-  const getTimeOnPage = useCallback6(() => {
+  const getTimeOnPage = useCallback8(() => {
     if (!pageLoadTimeRef.current)
       return 0;
     return Math.round((Date.now() - pageLoadTimeRef.current) / 1e3);
   }, []);
-  const reset = useCallback6(() => {
+  const reset = useCallback8(() => {
     scrollMilestonesRef.current.clear();
     pageLoadTimeRef.current = null;
     isTrackingTimeRef.current = false;
     timeTrackedRef.current.clear();
   }, []);
-  const share = useCallback6((platform, contentType) => {
+  const share = useCallback8((platform, contentType) => {
     track2("content_shared", {
       ...getBaseProps(),
       platform,
@@ -782,34 +2022,34 @@ function useBalanceEngagement(contentId, contentTitle) {
       time_on_page: getTimeOnPage()
     });
   }, [track2, getBaseProps, getTimeOnPage]);
-  const like = useCallback6((contentType) => {
+  const like = useCallback8((contentType) => {
     track2("content_liked", {
       ...getBaseProps(),
       content_type: contentType,
       time_on_page: getTimeOnPage()
     });
   }, [track2, getBaseProps, getTimeOnPage]);
-  const unlike = useCallback6((contentType) => {
+  const unlike = useCallback8((contentType) => {
     track2("content_unliked", {
       ...getBaseProps(),
       content_type: contentType
     });
   }, [track2, getBaseProps]);
-  const comment = useCallback6((commentLength) => {
+  const comment = useCallback8((commentLength) => {
     track2("comment_added", {
       ...getBaseProps(),
       comment_length: commentLength,
       time_on_page: getTimeOnPage()
     });
   }, [track2, getBaseProps, getTimeOnPage]);
-  const save = useCallback6((contentType) => {
+  const save = useCallback8((contentType) => {
     track2("content_saved", {
       ...getBaseProps(),
       content_type: contentType,
       time_on_page: getTimeOnPage()
     });
   }, [track2, getBaseProps, getTimeOnPage]);
-  const trackScrollDepth = useCallback6((scrollPercent) => {
+  const trackScrollDepth = useCallback8((scrollPercent) => {
     const milestones = [25, 50, 75, 100];
     milestones.forEach((milestone) => {
       if (scrollPercent >= milestone && !scrollMilestonesRef.current.has(milestone)) {
@@ -822,7 +2062,7 @@ function useBalanceEngagement(contentId, contentTitle) {
       }
     });
   }, [track2, getBaseProps, getTimeOnPage]);
-  const trackTimeOnPage = useCallback6(() => {
+  const trackTimeOnPage = useCallback8(() => {
     if (isTrackingTimeRef.current)
       return;
     pageLoadTimeRef.current = Date.now();
@@ -846,7 +2086,7 @@ function useBalanceEngagement(contentId, contentTitle) {
     }, 5e3);
     return () => clearInterval(intervalId);
   }, [track2, getBaseProps, getTimeOnPage]);
-  const click = useCallback6((elementType, elementId) => {
+  const click = useCallback8((elementType, elementId) => {
     track2("content_click", {
       ...getBaseProps(),
       element_type: elementType,
@@ -854,14 +2094,14 @@ function useBalanceEngagement(contentId, contentTitle) {
       time_on_page: getTimeOnPage()
     });
   }, [track2, getBaseProps, getTimeOnPage]);
-  const copy = useCallback6((textLength) => {
+  const copy = useCallback8((textLength) => {
     track2("content_copied", {
       ...getBaseProps(),
       text_length: textLength,
       time_on_page: getTimeOnPage()
     });
   }, [track2, getBaseProps, getTimeOnPage]);
-  const download = useCallback6((fileName, fileType) => {
+  const download = useCallback8((fileName, fileType) => {
     track2("content_downloaded", {
       ...getBaseProps(),
       file_name: fileName,
@@ -869,14 +2109,14 @@ function useBalanceEngagement(contentId, contentTitle) {
       time_on_page: getTimeOnPage()
     });
   }, [track2, getBaseProps, getTimeOnPage]);
-  const expand = useCallback6((sectionName) => {
+  const expand = useCallback8((sectionName) => {
     track2("content_expanded", {
       ...getBaseProps(),
       section_name: sectionName,
       time_on_page: getTimeOnPage()
     });
   }, [track2, getBaseProps, getTimeOnPage]);
-  useEffect4(() => {
+  useEffect9(() => {
     return () => {
       if (isTrackingTimeRef.current && pageLoadTimeRef.current) {
         const finalTime = getTimeOnPage();
@@ -914,34 +2154,34 @@ function useBalanceEngagement(contentId, contentTitle) {
 }
 
 // src/react/useBalanceForm.ts
-import { useCallback as useCallback7, useRef as useRef5 } from "react";
+import { useCallback as useCallback9, useRef as useRef8 } from "react";
 function useBalanceForm(formId, formName) {
   const { track: track2, identify: identify2 } = useBalance();
-  const startTimeRef = useRef5(null);
-  const fieldsRef = useRef5(/* @__PURE__ */ new Map());
-  const wasSubmittedRef = useRef5(false);
-  const hasStartedRef = useRef5(false);
-  const currentStepRef = useRef5(1);
-  const errorCountRef = useRef5(0);
-  const getBaseProps = useCallback7(() => ({
+  const startTimeRef = useRef8(null);
+  const fieldsRef = useRef8(/* @__PURE__ */ new Map());
+  const wasSubmittedRef = useRef8(false);
+  const hasStartedRef = useRef8(false);
+  const currentStepRef = useRef8(1);
+  const errorCountRef = useRef8(0);
+  const getBaseProps = useCallback9(() => ({
     form_id: formId,
     form_name: formName
   }), [formId, formName]);
-  const getFormDuration = useCallback7(() => {
+  const getFormDuration = useCallback9(() => {
     if (!startTimeRef.current)
       return 0;
     return Math.round((Date.now() - startTimeRef.current) / 1e3);
   }, []);
-  const getFieldsCompleted = useCallback7(() => {
+  const getFieldsCompleted = useCallback9(() => {
     return Array.from(fieldsRef.current.values()).filter((f) => f.completed).length;
   }, []);
-  const hasStarted = useCallback7(() => {
+  const hasStarted = useCallback9(() => {
     return hasStartedRef.current;
   }, []);
-  const wasSubmitted = useCallback7(() => {
+  const wasSubmitted = useCallback9(() => {
     return wasSubmittedRef.current;
   }, []);
-  const reset = useCallback7(() => {
+  const reset = useCallback9(() => {
     startTimeRef.current = null;
     fieldsRef.current.clear();
     wasSubmittedRef.current = false;
@@ -949,7 +2189,7 @@ function useBalanceForm(formId, formName) {
     currentStepRef.current = 1;
     errorCountRef.current = 0;
   }, []);
-  const formStart = useCallback7(() => {
+  const formStart = useCallback9(() => {
     if (hasStartedRef.current)
       return;
     startTimeRef.current = Date.now();
@@ -958,7 +2198,7 @@ function useBalanceForm(formId, formName) {
       ...getBaseProps()
     });
   }, [track2, getBaseProps]);
-  const formSubmit = useCallback7((email, additionalData) => {
+  const formSubmit = useCallback9((email, additionalData) => {
     wasSubmittedRef.current = true;
     const duration = getFormDuration();
     const fieldsCompleted = getFieldsCompleted();
@@ -980,7 +2220,7 @@ function useBalanceForm(formId, formName) {
       ...additionalData
     });
   }, [track2, identify2, getBaseProps, getFormDuration, getFieldsCompleted, formId, formName]);
-  const formAbandoned = useCallback7((reason) => {
+  const formAbandoned = useCallback9((reason) => {
     if (!hasStartedRef.current || wasSubmittedRef.current)
       return;
     const duration = getFormDuration();
@@ -1006,7 +2246,7 @@ function useBalanceForm(formId, formName) {
       reason
     });
   }, [track2, getBaseProps, getFormDuration, getFieldsCompleted]);
-  const fieldFocus = useCallback7((fieldName, fieldType) => {
+  const fieldFocus = useCallback9((fieldName, fieldType) => {
     if (!hasStartedRef.current) {
       formStart();
     }
@@ -1030,7 +2270,7 @@ function useBalanceForm(formId, formName) {
       existing.focusTime = Date.now();
     }
   }, [track2, getBaseProps, getFormDuration, formStart]);
-  const fieldBlur = useCallback7((fieldName, fieldType, hasValue) => {
+  const fieldBlur = useCallback9((fieldName, fieldType, hasValue) => {
     const field = fieldsRef.current.get(fieldName);
     if (field) {
       field.blurTime = Date.now();
@@ -1045,7 +2285,7 @@ function useBalanceForm(formId, formName) {
       });
     }
   }, [track2, getBaseProps]);
-  const fieldError = useCallback7((fieldName, errorMessage) => {
+  const fieldError = useCallback9((fieldName, errorMessage) => {
     errorCountRef.current += 1;
     const field = fieldsRef.current.get(fieldName);
     if (field) {
@@ -1058,7 +2298,7 @@ function useBalanceForm(formId, formName) {
       total_errors: errorCountRef.current
     });
   }, [track2, getBaseProps]);
-  const stepChange = useCallback7((fromStep, toStep, stepName) => {
+  const stepChange = useCallback9((fromStep, toStep, stepName) => {
     currentStepRef.current = toStep;
     track2("form_step_change", {
       ...getBaseProps(),
@@ -1091,32 +2331,32 @@ function useBalanceForm(formId, formName) {
 }
 
 // src/react/useBalanceSearch.ts
-import { useCallback as useCallback8, useRef as useRef6 } from "react";
+import { useCallback as useCallback10, useRef as useRef9 } from "react";
 function useBalanceSearch(searchContext) {
   const { track: track2 } = useBalance();
-  const searchCountRef = useRef6(0);
-  const clickCountRef = useRef6(0);
-  const filterCountRef = useRef6(0);
-  const activeFiltersRef = useRef6(/* @__PURE__ */ new Map());
-  const lastQueryRef = useRef6("");
-  const getBaseProps = useCallback8(() => ({
+  const searchCountRef = useRef9(0);
+  const clickCountRef = useRef9(0);
+  const filterCountRef = useRef9(0);
+  const activeFiltersRef = useRef9(/* @__PURE__ */ new Map());
+  const lastQueryRef = useRef9("");
+  const getBaseProps = useCallback10(() => ({
     search_context: searchContext,
     session_searches: searchCountRef.current,
     session_clicks: clickCountRef.current
   }), [searchContext]);
-  const getSearchStats = useCallback8(() => ({
+  const getSearchStats = useCallback10(() => ({
     searches: searchCountRef.current,
     clicks: clickCountRef.current,
     filters: filterCountRef.current
   }), []);
-  const reset = useCallback8(() => {
+  const reset = useCallback10(() => {
     searchCountRef.current = 0;
     clickCountRef.current = 0;
     filterCountRef.current = 0;
     activeFiltersRef.current.clear();
     lastQueryRef.current = "";
   }, []);
-  const search = useCallback8((query, resultCount, searchType) => {
+  const search = useCallback10((query, resultCount, searchType) => {
     searchCountRef.current += 1;
     lastQueryRef.current = query;
     track2("search", {
@@ -1129,7 +2369,7 @@ function useBalanceSearch(searchContext) {
       filter_count: activeFiltersRef.current.size
     });
   }, [track2, getBaseProps]);
-  const selectResult = useCallback8((query, resultId, position, resultType) => {
+  const selectResult = useCallback10((query, resultId, position, resultType) => {
     clickCountRef.current += 1;
     track2("search_result_click", {
       ...getBaseProps(),
@@ -1139,7 +2379,7 @@ function useBalanceSearch(searchContext) {
       result_type: resultType
     });
   }, [track2, getBaseProps]);
-  const noResults = useCallback8((query, searchType) => {
+  const noResults = useCallback10((query, searchType) => {
     searchCountRef.current += 1;
     lastQueryRef.current = query;
     track2("search_no_results", {
@@ -1150,7 +2390,7 @@ function useBalanceSearch(searchContext) {
       filter_count: activeFiltersRef.current.size
     });
   }, [track2, getBaseProps]);
-  const applyFilter = useCallback8((filter) => {
+  const applyFilter = useCallback10((filter) => {
     filterCountRef.current += 1;
     const filterKey = `${filter.category}:${filter.value}`;
     activeFiltersRef.current.set(filterKey, filter);
@@ -1162,7 +2402,7 @@ function useBalanceSearch(searchContext) {
       last_query: lastQueryRef.current
     });
   }, [track2, getBaseProps]);
-  const removeFilter = useCallback8((filter) => {
+  const removeFilter = useCallback10((filter) => {
     const filterKey = `${filter.category}:${filter.value}`;
     activeFiltersRef.current.delete(filterKey);
     track2("search_filter_remove", {
@@ -1173,7 +2413,7 @@ function useBalanceSearch(searchContext) {
       last_query: lastQueryRef.current
     });
   }, [track2, getBaseProps]);
-  const clearFilters = useCallback8(() => {
+  const clearFilters = useCallback10(() => {
     const filterCount = activeFiltersRef.current.size;
     activeFiltersRef.current.clear();
     track2("search_filters_clear", {
@@ -1182,7 +2422,7 @@ function useBalanceSearch(searchContext) {
       last_query: lastQueryRef.current
     });
   }, [track2, getBaseProps]);
-  const showSuggestions = useCallback8((query, suggestions) => {
+  const showSuggestions = useCallback10((query, suggestions) => {
     track2("search_suggestions_shown", {
       ...getBaseProps(),
       query,
@@ -1191,7 +2431,7 @@ function useBalanceSearch(searchContext) {
       // Limit to first 5
     });
   }, [track2, getBaseProps]);
-  const selectSuggestion = useCallback8((originalQuery, suggestion, position) => {
+  const selectSuggestion = useCallback10((originalQuery, suggestion, position) => {
     track2("search_suggestion_click", {
       ...getBaseProps(),
       original_query: originalQuery,
@@ -1199,7 +2439,7 @@ function useBalanceSearch(searchContext) {
       suggestion_position: position
     });
   }, [track2, getBaseProps]);
-  const refineSearch = useCallback8((originalQuery, newQuery) => {
+  const refineSearch = useCallback10((originalQuery, newQuery) => {
     track2("search_refined", {
       ...getBaseProps(),
       original_query: originalQuery,
@@ -1207,7 +2447,7 @@ function useBalanceSearch(searchContext) {
       refinement_type: newQuery.includes(originalQuery) ? "extended" : "modified"
     });
   }, [track2, getBaseProps]);
-  const loadMoreResults = useCallback8((query, page2, resultsLoaded) => {
+  const loadMoreResults = useCallback10((query, page2, resultsLoaded) => {
     track2("search_load_more", {
       ...getBaseProps(),
       search_term: query,
@@ -1215,7 +2455,7 @@ function useBalanceSearch(searchContext) {
       total_results_loaded: resultsLoaded
     });
   }, [track2, getBaseProps]);
-  const voiceSearch = useCallback8((transcript, resultCount) => {
+  const voiceSearch = useCallback10((transcript, resultCount) => {
     searchCountRef.current += 1;
     lastQueryRef.current = transcript;
     track2("voice_search", {
@@ -1248,31 +2488,31 @@ function useBalanceSearch(searchContext) {
 }
 
 // src/react/useBalanceNotification.ts
-import { useCallback as useCallback9, useRef as useRef7 } from "react";
+import { useCallback as useCallback11, useRef as useRef10 } from "react";
 function useBalanceNotification() {
   const { track: track2 } = useBalance();
-  const shownCountRef = useRef7(0);
-  const clickedCountRef = useRef7(0);
-  const dismissedCountRef = useRef7(0);
-  const notificationsSeenRef = useRef7(/* @__PURE__ */ new Set());
-  const getBaseProps = useCallback9(() => ({
+  const shownCountRef = useRef10(0);
+  const clickedCountRef = useRef10(0);
+  const dismissedCountRef = useRef10(0);
+  const notificationsSeenRef = useRef10(/* @__PURE__ */ new Set());
+  const getBaseProps = useCallback11(() => ({
     session_notifications_shown: shownCountRef.current,
     session_notifications_clicked: clickedCountRef.current
   }), []);
-  const getStats = useCallback9(() => {
+  const getStats = useCallback11(() => {
     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 = useCallback9(() => {
+  const reset = useCallback11(() => {
     shownCountRef.current = 0;
     clickedCountRef.current = 0;
     dismissedCountRef.current = 0;
     notificationsSeenRef.current.clear();
   }, []);
-  const shown = useCallback9((notificationId, type, campaign) => {
+  const shown = useCallback11((notificationId, type, campaign) => {
     if (notificationsSeenRef.current.has(notificationId))
       return;
     notificationsSeenRef.current.add(notificationId);
@@ -1284,7 +2524,7 @@ function useBalanceNotification() {
       campaign
     });
   }, [track2, getBaseProps]);
-  const clicked = useCallback9((notificationId, type, action) => {
+  const clicked = useCallback11((notificationId, type, action) => {
     clickedCountRef.current += 1;
     track2("notification_clicked", {
       ...getBaseProps(),
@@ -1293,7 +2533,7 @@ function useBalanceNotification() {
       action
     });
   }, [track2, getBaseProps]);
-  const dismissed = useCallback9((notificationId, type, reason) => {
+  const dismissed = useCallback11((notificationId, type, reason) => {
     dismissedCountRef.current += 1;
     track2("notification_dismissed", {
       ...getBaseProps(),
@@ -1302,33 +2542,33 @@ function useBalanceNotification() {
       dismiss_reason: reason
     });
   }, [track2, getBaseProps]);
-  const optIn = useCallback9((channel, source) => {
+  const optIn = useCallback11((channel, source) => {
     track2("notification_opt_in", {
       ...getBaseProps(),
       channel,
       opt_in_source: source
     });
   }, [track2, getBaseProps]);
-  const optOut = useCallback9((channel, reason) => {
+  const optOut = useCallback11((channel, reason) => {
     track2("notification_opt_out", {
       ...getBaseProps(),
       channel,
       opt_out_reason: reason
     });
   }, [track2, getBaseProps]);
-  const permissionRequested = useCallback9((channel) => {
+  const permissionRequested = useCallback11((channel) => {
     track2("notification_permission_requested", {
       ...getBaseProps(),
       channel
     });
   }, [track2, getBaseProps]);
-  const permissionDenied = useCallback9((channel) => {
+  const permissionDenied = useCallback11((channel) => {
     track2("notification_permission_denied", {
       ...getBaseProps(),
       channel
     });
   }, [track2, getBaseProps]);
-  const preferenceUpdated = useCallback9((preferences) => {
+  const preferenceUpdated = useCallback11((preferences) => {
     track2("notification_preferences_updated", {
       ...getBaseProps(),
       preferences: preferences.map((p) => ({
@@ -1339,7 +2579,7 @@ function useBalanceNotification() {
       enabled_channels: preferences.filter((p) => p.enabled).map((p) => p.channel)
     });
   }, [track2, getBaseProps]);
-  const emailOpened = useCallback9((emailId, campaign, subject) => {
+  const emailOpened = useCallback11((emailId, campaign, subject) => {
     track2("email_opened", {
       ...getBaseProps(),
       email_id: emailId,
@@ -1347,7 +2587,7 @@ function useBalanceNotification() {
       subject
     });
   }, [track2, getBaseProps]);
-  const emailLinkClicked = useCallback9((emailId, linkUrl, linkName) => {
+  const emailLinkClicked = useCallback11((emailId, linkUrl, linkName) => {
     track2("email_link_clicked", {
       ...getBaseProps(),
       email_id: emailId,
@@ -1355,7 +2595,7 @@ function useBalanceNotification() {
       link_name: linkName
     });
   }, [track2, getBaseProps]);
-  const emailUnsubscribed = useCallback9((emailId, reason, category) => {
+  const emailUnsubscribed = useCallback11((emailId, reason, category) => {
     track2("email_unsubscribed", {
       ...getBaseProps(),
       email_id: emailId,
@@ -1363,14 +2603,14 @@ function useBalanceNotification() {
       category
     });
   }, [track2, getBaseProps]);
-  const pushReceived = useCallback9((notificationId, campaign) => {
+  const pushReceived = useCallback11((notificationId, campaign) => {
     track2("push_received", {
       ...getBaseProps(),
       notification_id: notificationId,
       campaign
     });
   }, [track2, getBaseProps]);
-  const inAppInteraction = useCallback9((messageId, interactionType, elementClicked) => {
+  const inAppInteraction = useCallback11((messageId, interactionType, elementClicked) => {
     if (interactionType === "view")
       shownCountRef.current += 1;
     if (interactionType === "click")
@@ -1409,33 +2649,33 @@ function useBalanceNotification() {
 }
 
 // src/react/useBalanceSocial.ts
-import { useCallback as useCallback10, useRef as useRef8 } from "react";
+import { useCallback as useCallback12, useRef as useRef11 } from "react";
 function useBalanceSocial() {
   const { track: track2 } = useBalance();
-  const followsRef = useRef8(0);
-  const unfollowsRef = useRef8(0);
-  const profileViewsRef = useRef8(0);
-  const postsCreatedRef = useRef8(0);
-  const viewedProfilesRef = useRef8(/* @__PURE__ */ new Set());
-  const getBaseProps = useCallback10(() => ({
+  const followsRef = useRef11(0);
+  const unfollowsRef = useRef11(0);
+  const profileViewsRef = useRef11(0);
+  const postsCreatedRef = useRef11(0);
+  const viewedProfilesRef = useRef11(/* @__PURE__ */ new Set());
+  const getBaseProps = useCallback12(() => ({
     session_follows: followsRef.current,
     session_unfollows: unfollowsRef.current,
     session_profile_views: profileViewsRef.current
   }), []);
-  const getStats = useCallback10(() => ({
+  const getStats = useCallback12(() => ({
     follows: followsRef.current,
     unfollows: unfollowsRef.current,
     profileViews: profileViewsRef.current,
     postsCreated: postsCreatedRef.current
   }), []);
-  const reset = useCallback10(() => {
+  const reset = useCallback12(() => {
     followsRef.current = 0;
     unfollowsRef.current = 0;
     profileViewsRef.current = 0;
     postsCreatedRef.current = 0;
     viewedProfilesRef.current.clear();
   }, []);
-  const viewProfile = useCallback10((entityId, entityType, source) => {
+  const viewProfile = useCallback12((entityId, entityType, source) => {
     const profileKey = `${entityType}:${entityId}`;
     const isFirstView = !viewedProfilesRef.current.has(profileKey);
     if (isFirstView) {
@@ -1450,7 +2690,7 @@ function useBalanceSocial() {
       is_first_view: isFirstView
     });
   }, [track2, getBaseProps]);
-  const follow = useCallback10((entityId, entityType, source) => {
+  const follow = useCallback12((entityId, entityType, source) => {
     followsRef.current += 1;
     track2("follow", {
       ...getBaseProps(),
@@ -1459,7 +2699,7 @@ function useBalanceSocial() {
       source
     });
   }, [track2, getBaseProps]);
-  const unfollow = useCallback10((entityId, entityType, reason) => {
+  const unfollow = useCallback12((entityId, entityType, reason) => {
     unfollowsRef.current += 1;
     track2("unfollow", {
       ...getBaseProps(),
@@ -1468,7 +2708,7 @@ function useBalanceSocial() {
       reason
     });
   }, [track2, getBaseProps]);
-  const block = useCallback10((entityId, entityType, reason) => {
+  const block = useCallback12((entityId, entityType, reason) => {
     track2("block", {
       ...getBaseProps(),
       entity_id: entityId,
@@ -1476,14 +2716,14 @@ function useBalanceSocial() {
       reason
     });
   }, [track2, getBaseProps]);
-  const mute = useCallback10((entityId, entityType) => {
+  const mute = useCallback12((entityId, entityType) => {
     track2("mute", {
       ...getBaseProps(),
       entity_id: entityId,
       entity_type: entityType
     });
   }, [track2, getBaseProps]);
-  const report = useCallback10((entityId, entityType, reason, details) => {
+  const report = useCallback12((entityId, entityType, reason, details) => {
     track2("report", {
       ...getBaseProps(),
       entity_id: entityId,
@@ -1492,7 +2732,7 @@ function useBalanceSocial() {
       details
     });
   }, [track2, getBaseProps]);
-  const mention = useCallback10((mentionedId, mentionedType, context) => {
+  const mention = useCallback12((mentionedId, mentionedType, context) => {
     track2("mention_sent", {
       ...getBaseProps(),
       mentioned_id: mentionedId,
@@ -1500,7 +2740,7 @@ function useBalanceSocial() {
       context
     });
   }, [track2, getBaseProps]);
-  const wasMentioned = useCallback10((byUserId, context, contentId) => {
+  const wasMentioned = useCallback12((byUserId, context, contentId) => {
     track2("mention_received", {
       ...getBaseProps(),
       by_user_id: byUserId,
@@ -1508,21 +2748,21 @@ function useBalanceSocial() {
       content_id: contentId
     });
   }, [track2, getBaseProps]);
-  const inviteSent = useCallback10((channel, recipientCount) => {
+  const inviteSent = useCallback12((channel, recipientCount) => {
     track2("invite_sent", {
       ...getBaseProps(),
       channel,
       recipient_count: recipientCount || 1
     });
   }, [track2, getBaseProps]);
-  const inviteAccepted = useCallback10((inviteCode, inviterId) => {
+  const inviteAccepted = useCallback12((inviteCode, inviterId) => {
     track2("invite_accepted", {
       ...getBaseProps(),
       invite_code: inviteCode,
       inviter_id: inviterId
     });
   }, [track2, getBaseProps]);
-  const joinCommunity = useCallback10((communityId, communityName, source) => {
+  const joinCommunity = useCallback12((communityId, communityName, source) => {
     track2("community_joined", {
       ...getBaseProps(),
       community_id: communityId,
@@ -1530,7 +2770,7 @@ function useBalanceSocial() {
       source
     });
   }, [track2, getBaseProps]);
-  const leaveCommunity = useCallback10((communityId, communityName, reason) => {
+  const leaveCommunity = useCallback12((communityId, communityName, reason) => {
     track2("community_left", {
       ...getBaseProps(),
       community_id: communityId,
@@ -1538,7 +2778,7 @@ function useBalanceSocial() {
       reason
     });
   }, [track2, getBaseProps]);
-  const createPost = useCallback10((postId, postType, communityId) => {
+  const createPost = useCallback12((postId, postType, communityId) => {
     postsCreatedRef.current += 1;
     track2("post_created", {
       ...getBaseProps(),
@@ -1547,7 +2787,7 @@ function useBalanceSocial() {
       community_id: communityId
     });
   }, [track2, getBaseProps]);
-  const replyToPost = useCallback10((postId, replyId, depth) => {
+  const replyToPost = useCallback12((postId, replyId, depth) => {
     track2("reply_created", {
       ...getBaseProps(),
       post_id: postId,
@@ -1555,7 +2795,7 @@ function useBalanceSocial() {
       depth: depth || 1
     });
   }, [track2, getBaseProps]);
-  const react = useCallback10((contentId, reactionType, contentType) => {
+  const react = useCallback12((contentId, reactionType, contentType) => {
     track2("reaction", {
       ...getBaseProps(),
       content_id: contentId,
@@ -1563,27 +2803,27 @@ function useBalanceSocial() {
       content_type: contentType
     });
   }, [track2, getBaseProps]);
-  const editProfile = useCallback10((fieldsEdited) => {
+  const editProfile = useCallback12((fieldsEdited) => {
     track2("profile_edited", {
       ...getBaseProps(),
       fields_edited: fieldsEdited,
       field_count: fieldsEdited.length
     });
   }, [track2, getBaseProps]);
-  const changeAvatar = useCallback10((source) => {
+  const changeAvatar = useCallback12((source) => {
     track2("avatar_changed", {
       ...getBaseProps(),
       source
     });
   }, [track2, getBaseProps]);
-  const connectionRequest = useCallback10((targetId, targetType) => {
+  const connectionRequest = useCallback12((targetId, targetType) => {
     track2("connection_requested", {
       ...getBaseProps(),
       target_id: targetId,
       target_type: targetType
     });
   }, [track2, getBaseProps]);
-  const connectionAccepted = useCallback10((requesterId, requesterType) => {
+  const connectionAccepted = useCallback12((requesterId, requesterType) => {
     track2("connection_accepted", {
       ...getBaseProps(),
       requester_id: requesterId,
@@ -1624,34 +2864,34 @@ function useBalanceSocial() {
 }
 
 // src/react/useBalanceAuth.ts
-import { useCallback as useCallback11, useRef as useRef9 } from "react";
+import { useCallback as useCallback13, useRef as useRef12 } from "react";
 function useBalanceAuth() {
   const { track: track2, identify: identify2 } = useBalance();
-  const loginAttemptsRef = useRef9(0);
-  const loginSuccessesRef = useRef9(0);
-  const loginFailuresRef = useRef9(0);
-  const authStartTimeRef = useRef9(null);
-  const getBaseProps = useCallback11(() => ({
+  const loginAttemptsRef = useRef12(0);
+  const loginSuccessesRef = useRef12(0);
+  const loginFailuresRef = useRef12(0);
+  const authStartTimeRef = useRef12(null);
+  const getBaseProps = useCallback13(() => ({
     session_login_attempts: loginAttemptsRef.current,
     session_login_successes: loginSuccessesRef.current
   }), []);
-  const getAuthDuration = useCallback11(() => {
+  const getAuthDuration = useCallback13(() => {
     if (!authStartTimeRef.current)
       return 0;
     return Math.round((Date.now() - authStartTimeRef.current) / 1e3);
   }, []);
-  const getStats = useCallback11(() => ({
+  const getStats = useCallback13(() => ({
     loginAttempts: loginAttemptsRef.current,
     loginSuccesses: loginSuccessesRef.current,
     loginFailures: loginFailuresRef.current
   }), []);
-  const reset = useCallback11(() => {
+  const reset = useCallback13(() => {
     loginAttemptsRef.current = 0;
     loginSuccessesRef.current = 0;
     loginFailuresRef.current = 0;
     authStartTimeRef.current = null;
   }, []);
-  const signUpStart = useCallback11((method, source) => {
+  const signUpStart = useCallback13((method, source) => {
     authStartTimeRef.current = Date.now();
     track2("sign_up_start", {
       ...getBaseProps(),
@@ -1659,7 +2899,7 @@ function useBalanceAuth() {
       source
     });
   }, [track2, getBaseProps]);
-  const signUpSuccess = useCallback11((method, email) => {
+  const signUpSuccess = useCallback13((method, email) => {
     loginSuccessesRef.current += 1;
     if (email) {
       identify2(email, { auth_method: method, signup_date: (/* @__PURE__ */ new Date()).toISOString() });
@@ -1671,7 +2911,7 @@ function useBalanceAuth() {
     });
     authStartTimeRef.current = null;
   }, [track2, identify2, getBaseProps, getAuthDuration]);
-  const signUpFailed = useCallback11((method, errorCode, errorMessage) => {
+  const signUpFailed = useCallback13((method, errorCode, errorMessage) => {
     loginFailuresRef.current += 1;
     track2("sign_up_failed", {
       ...getBaseProps(),
@@ -1681,19 +2921,19 @@ function useBalanceAuth() {
       duration_seconds: getAuthDuration()
     });
   }, [track2, getBaseProps, getAuthDuration]);
-  const verificationSent = useCallback11((method) => {
+  const verificationSent = useCallback13((method) => {
     track2("verification_sent", {
       ...getBaseProps(),
       method
     });
   }, [track2, getBaseProps]);
-  const verified = useCallback11((method) => {
+  const verified = useCallback13((method) => {
     track2("verified", {
       ...getBaseProps(),
       method
     });
   }, [track2, getBaseProps]);
-  const loginStart = useCallback11((method, source) => {
+  const loginStart = useCallback13((method, source) => {
     loginAttemptsRef.current += 1;
     authStartTimeRef.current = Date.now();
     track2("login_start", {
@@ -1702,7 +2942,7 @@ function useBalanceAuth() {
       source
     });
   }, [track2, getBaseProps]);
-  const loginSuccess = useCallback11((method, email) => {
+  const loginSuccess = useCallback13((method, email) => {
     loginSuccessesRef.current += 1;
     if (email) {
       identify2(email, { auth_method: method, last_login: (/* @__PURE__ */ new Date()).toISOString() });
@@ -1714,7 +2954,7 @@ function useBalanceAuth() {
     });
     authStartTimeRef.current = null;
   }, [track2, identify2, getBaseProps, getAuthDuration]);
-  const loginFailed = useCallback11((method, errorCode, errorMessage) => {
+  const loginFailed = useCallback13((method, errorCode, errorMessage) => {
     loginFailuresRef.current += 1;
     track2("login_failed", {
       ...getBaseProps(),
@@ -1724,108 +2964,108 @@ function useBalanceAuth() {
       duration_seconds: getAuthDuration()
     });
   }, [track2, getBaseProps, getAuthDuration]);
-  const logout = useCallback11((reason = "user_initiated") => {
+  const logout = useCallback13((reason = "user_initiated") => {
     track2("logout", {
       ...getBaseProps(),
       reason
     });
   }, [track2, getBaseProps]);
-  const passwordResetRequested = useCallback11((method) => {
+  const passwordResetRequested = useCallback13((method) => {
     track2("password_reset_requested", {
       ...getBaseProps(),
       method
     });
   }, [track2, getBaseProps]);
-  const passwordResetCompleted = useCallback11(() => {
+  const passwordResetCompleted = useCallback13(() => {
     track2("password_reset_completed", {
       ...getBaseProps()
     });
   }, [track2, getBaseProps]);
-  const passwordChanged = useCallback11((source) => {
+  const passwordChanged = useCallback13((source) => {
     track2("password_changed", {
       ...getBaseProps(),
       source
     });
   }, [track2, getBaseProps]);
-  const mfaSetupStart = useCallback11((method) => {
+  const mfaSetupStart = useCallback13((method) => {
     track2("mfa_setup_start", {
       ...getBaseProps(),
       method
     });
   }, [track2, getBaseProps]);
-  const mfaSetupCompleted = useCallback11((method) => {
+  const mfaSetupCompleted = useCallback13((method) => {
     track2("mfa_setup_completed", {
       ...getBaseProps(),
       method
     });
   }, [track2, getBaseProps]);
-  const mfaChallenge = useCallback11((method) => {
+  const mfaChallenge = useCallback13((method) => {
     track2("mfa_challenge", {
       ...getBaseProps(),
       method
     });
   }, [track2, getBaseProps]);
-  const mfaSuccess = useCallback11((method) => {
+  const mfaSuccess = useCallback13((method) => {
     track2("mfa_success", {
       ...getBaseProps(),
       method
     });
   }, [track2, getBaseProps]);
-  const mfaFailed = useCallback11((method, reason) => {
+  const mfaFailed = useCallback13((method, reason) => {
     track2("mfa_failed", {
       ...getBaseProps(),
       method,
       reason
     });
   }, [track2, getBaseProps]);
-  const mfaDisabled = useCallback11((method) => {
+  const mfaDisabled = useCallback13((method) => {
     track2("mfa_disabled", {
       ...getBaseProps(),
       method
     });
   }, [track2, getBaseProps]);
-  const sessionStart = useCallback11((isNewUser, authMethod) => {
+  const sessionStart = useCallback13((isNewUser, authMethod) => {
     track2("session_start", {
       ...getBaseProps(),
       is_new_user: isNewUser,
       auth_method: authMethod
     });
   }, [track2, getBaseProps]);
-  const sessionResume = useCallback11(() => {
+  const sessionResume = useCallback13(() => {
     track2("session_resume", {
       ...getBaseProps()
     });
   }, [track2, getBaseProps]);
-  const sessionExpired = useCallback11((durationSeconds) => {
+  const sessionExpired = useCallback13((durationSeconds) => {
     track2("session_expired", {
       ...getBaseProps(),
       duration_seconds: durationSeconds
     });
   }, [track2, getBaseProps]);
-  const sessionRefreshed = useCallback11(() => {
+  const sessionRefreshed = useCallback13(() => {
     track2("session_refreshed", {
       ...getBaseProps()
     });
   }, [track2, getBaseProps]);
-  const accountDeletionRequested = useCallback11((reason) => {
+  const accountDeletionRequested = useCallback13((reason) => {
     track2("account_deletion_requested", {
       ...getBaseProps(),
       reason
     });
   }, [track2, getBaseProps]);
-  const accountDeleted = useCallback11((reason) => {
+  const accountDeleted = useCallback13((reason) => {
     track2("account_deleted", {
       ...getBaseProps(),
       reason
     });
   }, [track2, getBaseProps]);
-  const accountLinked = useCallback11((method) => {
+  const accountLinked = useCallback13((method) => {
     track2("account_linked", {
       ...getBaseProps(),
       method
     });
   }, [track2, getBaseProps]);
-  const accountUnlinked = useCallback11((method) => {
+  const accountUnlinked = useCallback13((method) => {
     track2("account_unlinked", {
       ...getBaseProps(),
       method
@@ -1871,25 +3111,25 @@ function useBalanceAuth() {
 }
 
 // src/react/useBalanceError.ts
-import { useCallback as useCallback12, useRef as useRef10 } from "react";
+import { useCallback as useCallback14, useRef as useRef13 } from "react";
 function useBalanceError() {
   const { track: track2 } = useBalance();
-  const errorCountRef = useRef10(0);
-  const apiErrorCountRef = useRef10(0);
-  const userReportCountRef = useRef10(0);
-  const pageLoadTimesRef = useRef10([]);
-  const measureStartTimesRef = useRef10(/* @__PURE__ */ new Map());
-  const capturedErrorsRef = useRef10(/* @__PURE__ */ new Set());
-  const getBaseProps = useCallback12(() => ({
+  const errorCountRef = useRef13(0);
+  const apiErrorCountRef = useRef13(0);
+  const userReportCountRef = useRef13(0);
+  const pageLoadTimesRef = useRef13([]);
+  const measureStartTimesRef = useRef13(/* @__PURE__ */ new Map());
+  const capturedErrorsRef = useRef13(/* @__PURE__ */ new Set());
+  const getBaseProps = useCallback14(() => ({
     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 = useCallback12((error) => {
+  const getErrorFingerprint = useCallback14((error) => {
     return `${error.name}:${error.message}:${error.stack?.split("\n")[1] || ""}`;
   }, []);
-  const getStats = useCallback12(() => {
+  const getStats = useCallback14(() => {
     const times = pageLoadTimesRef.current;
     const avgPageLoad = times.length > 0 ? Math.round(times.reduce((a, b) => a + b, 0) / times.length) : null;
     return {
@@ -1899,7 +3139,7 @@ function useBalanceError() {
       avgPageLoad
     };
   }, []);
-  const reset = useCallback12(() => {
+  const reset = useCallback14(() => {
     errorCountRef.current = 0;
     apiErrorCountRef.current = 0;
     userReportCountRef.current = 0;
@@ -1907,7 +3147,7 @@ function useBalanceError() {
     measureStartTimesRef.current.clear();
     capturedErrorsRef.current.clear();
   }, []);
-  const captureError = useCallback12((error, context, severity = "error") => {
+  const captureError = useCallback14((error, context, severity = "error") => {
     const fingerprint = getErrorFingerprint(error);
     if (capturedErrorsRef.current.has(fingerprint))
       return;
@@ -1923,7 +3163,7 @@ function useBalanceError() {
       ...context
     });
   }, [track2, getBaseProps, getErrorFingerprint]);
-  const captureApiError = useCallback12((details, context) => {
+  const captureApiError = useCallback14((details, context) => {
     apiErrorCountRef.current += 1;
     track2("api_error", {
       ...getBaseProps(),
@@ -1936,7 +3176,7 @@ function useBalanceError() {
       ...context
     });
   }, [track2, getBaseProps]);
-  const captureUserReport = useCallback12((category, description, metadata) => {
+  const captureUserReport = useCallback14((category, description, metadata) => {
     userReportCountRef.current += 1;
     track2("user_report", {
       ...getBaseProps(),
@@ -1945,7 +3185,7 @@ function useBalanceError() {
       ...metadata
     });
   }, [track2, getBaseProps]);
-  const captureComponentError = useCallback12((error, componentName, componentStack) => {
+  const captureComponentError = useCallback14((error, componentName, componentStack) => {
     errorCountRef.current += 1;
     track2("component_error", {
       ...getBaseProps(),
@@ -1955,7 +3195,7 @@ function useBalanceError() {
       component_stack: componentStack?.slice(0, 1e3)
     });
   }, [track2, getBaseProps]);
-  const captureUnhandledRejection = useCallback12((reason, promiseInfo) => {
+  const captureUnhandledRejection = useCallback14((reason, promiseInfo) => {
     errorCountRef.current += 1;
     const message = reason instanceof Error ? reason.message : String(reason);
     track2("unhandled_rejection", {
@@ -1964,7 +3204,7 @@ function useBalanceError() {
       promise_info: promiseInfo
     });
   }, [track2, getBaseProps]);
-  const captureResourceError = useCallback12((resourceUrl, resourceType, details) => {
+  const captureResourceError = useCallback14((resourceUrl, resourceType, details) => {
     track2("resource_error", {
       ...getBaseProps(),
       resource_url: resourceUrl,
@@ -1972,7 +3212,7 @@ function useBalanceError() {
       ...details
     });
   }, [track2, getBaseProps]);
-  const trackPerformance = useCallback12((metricType, valueMs, context) => {
+  const trackPerformance = useCallback14((metricType, valueMs, context) => {
     if (metricType === "page_load") {
       pageLoadTimesRef.current.push(valueMs);
     }
@@ -1983,7 +3223,7 @@ function useBalanceError() {
       ...context
     });
   }, [track2, getBaseProps]);
-  const trackWebVitals = useCallback12((vitals) => {
+  const trackWebVitals = useCallback14((vitals) => {
     track2("web_vitals", {
       ...getBaseProps(),
       lcp_ms: vitals.lcp ? Math.round(vitals.lcp) : void 0,
@@ -1993,7 +3233,7 @@ function useBalanceError() {
       ttfb_ms: vitals.ttfb ? Math.round(vitals.ttfb) : void 0
     });
   }, [track2, getBaseProps]);
-  const trackSlowInteraction = useCallback12((interactionType, durationMs, targetElement) => {
+  const trackSlowInteraction = useCallback14((interactionType, durationMs, targetElement) => {
     track2("slow_interaction", {
       ...getBaseProps(),
       interaction_type: interactionType,
@@ -2001,10 +3241,10 @@ function useBalanceError() {
       target_element: targetElement
     });
   }, [track2, getBaseProps]);
-  const startMeasure = useCallback12((measureName) => {
+  const startMeasure = useCallback14((measureName) => {
     measureStartTimesRef.current.set(measureName, performance.now());
   }, []);
-  const endMeasure = useCallback12((measureName, metricType = "interaction") => {
+  const endMeasure = useCallback14((measureName, metricType = "interaction") => {
     const startTime = measureStartTimesRef.current.get(measureName);
     if (!startTime)
       return null;
@@ -2035,22 +3275,22 @@ function useBalanceError() {
 }
 
 // src/react/useBalanceAB.ts
-import { useCallback as useCallback13, useRef as useRef11, useEffect as useEffect5 } from "react";
+import { useCallback as useCallback15, useRef as useRef14, useEffect as useEffect10 } from "react";
 function useBalanceAB() {
   const { track: track2 } = useBalance();
-  const exposuresRef = useRef11(0);
-  const conversionsRef = useRef11(0);
-  const activeExperimentsRef = useRef11(/* @__PURE__ */ new Map());
-  const exposedExperimentsRef = useRef11(/* @__PURE__ */ new Set());
-  const getBaseProps = useCallback13(() => ({
+  const exposuresRef = useRef14(0);
+  const conversionsRef = useRef14(0);
+  const activeExperimentsRef = useRef14(/* @__PURE__ */ new Map());
+  const exposedExperimentsRef = useRef14(/* @__PURE__ */ new Set());
+  const getBaseProps = useCallback15(() => ({
     session_exposures: exposuresRef.current,
     session_conversions: conversionsRef.current,
     active_experiment_count: activeExperimentsRef.current.size
   }), []);
-  const getStorageKey = useCallback13((experimentId) => {
+  const getStorageKey = useCallback15((experimentId) => {
     return `balance_ab_${experimentId}`;
   }, []);
-  const getVariant = useCallback13((experimentId) => {
+  const getVariant = useCallback15((experimentId) => {
     if (typeof window === "undefined")
       return null;
     try {
@@ -2060,7 +3300,7 @@ function useBalanceAB() {
       return null;
     }
   }, [getStorageKey]);
-  const setVariant = useCallback13((experimentId, variant) => {
+  const setVariant = useCallback15((experimentId, variant) => {
     if (typeof window === "undefined")
       return;
     try {
@@ -2069,10 +3309,10 @@ function useBalanceAB() {
     } catch {
     }
   }, [getStorageKey]);
-  const getActiveExperiments = useCallback13(() => {
+  const getActiveExperiments = useCallback15(() => {
     return new Map(activeExperimentsRef.current);
   }, []);
-  const getStats = useCallback13(() => {
+  const getStats = useCallback15(() => {
     const exposures = exposuresRef.current;
     const conversions = conversionsRef.current;
     const conversionRate = exposures > 0 ? Math.round(conversions / exposures * 1e4) / 100 : 0;
@@ -2083,13 +3323,13 @@ function useBalanceAB() {
       conversionRate
     };
   }, []);
-  const reset = useCallback13(() => {
+  const reset = useCallback15(() => {
     exposuresRef.current = 0;
     conversionsRef.current = 0;
     activeExperimentsRef.current.clear();
     exposedExperimentsRef.current.clear();
   }, []);
-  useEffect5(() => {
+  useEffect10(() => {
     if (typeof window === "undefined")
       return;
     try {
@@ -2106,7 +3346,7 @@ function useBalanceAB() {
     } catch {
     }
   }, []);
-  const trackExposure = useCallback13((experimentId, variant, context) => {
+  const trackExposure = useCallback15((experimentId, variant, context) => {
     const exposureKey = `${experimentId}:${variant}`;
     if (exposedExperimentsRef.current.has(exposureKey))
       return;
@@ -2121,7 +3361,7 @@ function useBalanceAB() {
       ...context
     });
   }, [track2, getBaseProps]);
-  const trackConversion = useCallback13((experimentId, variant, conversionData) => {
+  const trackConversion = useCallback15((experimentId, variant, conversionData) => {
     conversionsRef.current += 1;
     track2("experiment_conversion", {
       ...getBaseProps(),
@@ -2130,7 +3370,7 @@ function useBalanceAB() {
       ...conversionData
     });
   }, [track2, getBaseProps]);
-  const trackInteraction = useCallback13((experimentId, variant, interactionType, details) => {
+  const trackInteraction = useCallback15((experimentId, variant, interactionType, details) => {
     track2("experiment_interaction", {
       ...getBaseProps(),
       experiment_id: experimentId,
@@ -2139,7 +3379,7 @@ function useBalanceAB() {
       ...details
     });
   }, [track2, getBaseProps]);
-  const enrollUser = useCallback13((experimentId, variant, source = "random") => {
+  const enrollUser = useCallback15((experimentId, variant, source = "random") => {
     setVariant(experimentId, variant);
     track2("experiment_enrolled", {
       ...getBaseProps(),
@@ -2148,7 +3388,7 @@ function useBalanceAB() {
       enrollment_source: source
     });
   }, [track2, getBaseProps, setVariant]);
-  const exitExperiment = useCallback13((experimentId, reason = "completed") => {
+  const exitExperiment = useCallback15((experimentId, reason = "completed") => {
     const variant = activeExperimentsRef.current.get(experimentId);
     activeExperimentsRef.current.delete(experimentId);
     track2("experiment_exit", {
@@ -2158,7 +3398,7 @@ function useBalanceAB() {
       exit_reason: reason
     });
   }, [track2, getBaseProps]);
-  const trackFeatureFlag = useCallback13((flag) => {
+  const trackFeatureFlag = useCallback15((flag) => {
     track2("feature_flag_evaluated", {
       ...getBaseProps(),
       flag_key: flag.key,
@@ -2167,7 +3407,7 @@ function useBalanceAB() {
       flag_source: flag.source || "unknown"
     });
   }, [track2, getBaseProps]);
-  const trackFeatureFlagToggle = useCallback13((flagKey, newValue, previousValue) => {
+  const trackFeatureFlagToggle = useCallback15((flagKey, newValue, previousValue) => {
     track2("feature_flag_toggled", {
       ...getBaseProps(),
       flag_key: flagKey,
@@ -2175,7 +3415,7 @@ function useBalanceAB() {
       previous_value: previousValue
     });
   }, [track2, getBaseProps]);
-  const trackGoal = useCallback13((experimentId, goalName, value, context) => {
+  const trackGoal = useCallback15((experimentId, goalName, value, context) => {
     const variant = activeExperimentsRef.current.get(experimentId);
     track2("experiment_goal", {
       ...getBaseProps(),
@@ -2186,7 +3426,7 @@ function useBalanceAB() {
       ...context
     });
   }, [track2, getBaseProps]);
-  const trackSegment = useCallback13((segmentId, segmentName, criteria) => {
+  const trackSegment = useCallback15((segmentId, segmentName, criteria) => {
     track2("segment_assigned", {
       ...getBaseProps(),
       segment_id: segmentId,
@@ -2218,37 +3458,37 @@ function useBalanceAB() {
 }
 
 // src/react/useBalanceLive.ts
-import { useCallback as useCallback14, useRef as useRef12, useEffect as useEffect6 } from "react";
+import { useCallback as useCallback16, useRef as useRef15, useEffect as useEffect11 } from "react";
 function useBalanceLive() {
   const { track: track2 } = useBalance();
-  const currentStreamRef = useRef12(null);
-  const streamStartTimeRef = useRef12(null);
-  const totalWatchTimeRef = useRef12(0);
-  const messageCountRef = useRef12(0);
-  const reactionCountRef = useRef12(0);
-  const tipCountRef = useRef12(0);
-  const lastMilestoneRef = useRef12(0);
-  const watchTimeIntervalRef = useRef12(null);
-  const getCurrentWatchTime = useCallback14(() => {
+  const currentStreamRef = useRef15(null);
+  const streamStartTimeRef = useRef15(null);
+  const totalWatchTimeRef = useRef15(0);
+  const messageCountRef = useRef15(0);
+  const reactionCountRef = useRef15(0);
+  const tipCountRef = useRef15(0);
+  const lastMilestoneRef = useRef15(0);
+  const watchTimeIntervalRef = useRef15(null);
+  const getCurrentWatchTime = useCallback16(() => {
     if (!streamStartTimeRef.current)
       return 0;
     return Math.round((Date.now() - streamStartTimeRef.current) / 1e3);
   }, []);
-  const getBaseProps = useCallback14(() => ({
+  const getBaseProps = useCallback16(() => ({
     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 = useCallback14(() => ({
+  const getStats = useCallback16(() => ({
     totalWatchTimeSeconds: totalWatchTimeRef.current + getCurrentWatchTime(),
     messagesent: messageCountRef.current,
     reactions: reactionCountRef.current,
     tips: tipCountRef.current,
     currentStreamId: currentStreamRef.current
   }), [getCurrentWatchTime]);
-  const reset = useCallback14(() => {
+  const reset = useCallback16(() => {
     if (watchTimeIntervalRef.current) {
       clearInterval(watchTimeIntervalRef.current);
       watchTimeIntervalRef.current = null;
@@ -2261,14 +3501,14 @@ function useBalanceLive() {
     tipCountRef.current = 0;
     lastMilestoneRef.current = 0;
   }, []);
-  useEffect6(() => {
+  useEffect11(() => {
     return () => {
       if (watchTimeIntervalRef.current) {
         clearInterval(watchTimeIntervalRef.current);
       }
     };
   }, []);
-  const joinStream = useCallback14((streamId, streamTitle, artistId, metadata) => {
+  const joinStream = useCallback16((streamId, streamTitle, artistId, metadata) => {
     if (currentStreamRef.current && currentStreamRef.current !== streamId) {
       totalWatchTimeRef.current += getCurrentWatchTime();
     }
@@ -2297,7 +3537,7 @@ function useBalanceLive() {
       }
     }, 6e4);
   }, [track2, getBaseProps, getCurrentWatchTime]);
-  const leaveStream = useCallback14((streamId, reason = "user") => {
+  const leaveStream = useCallback16((streamId, reason = "user") => {
     const watchTime = getCurrentWatchTime();
     totalWatchTimeRef.current += watchTime;
     if (watchTimeIntervalRef.current) {
@@ -2313,7 +3553,7 @@ function useBalanceLive() {
     currentStreamRef.current = null;
     streamStartTimeRef.current = null;
   }, [track2, getBaseProps, getCurrentWatchTime]);
-  const playbackStarted = useCallback14((streamId, quality, latencyMs) => {
+  const playbackStarted = useCallback16((streamId, quality, latencyMs) => {
     track2("stream_playback_started", {
       ...getBaseProps(),
       stream_id: streamId,
@@ -2321,7 +3561,7 @@ function useBalanceLive() {
       latency_ms: latencyMs
     });
   }, [track2, getBaseProps]);
-  const buffering = useCallback14((streamId, durationMs, reason) => {
+  const buffering = useCallback16((streamId, durationMs, reason) => {
     track2("stream_buffering", {
       ...getBaseProps(),
       stream_id: streamId,
@@ -2329,7 +3569,7 @@ function useBalanceLive() {
       buffer_reason: reason
     });
   }, [track2, getBaseProps]);
-  const qualityChanged = useCallback14((streamId, previousQuality, newQuality, isAutomatic) => {
+  const qualityChanged = useCallback16((streamId, previousQuality, newQuality, isAutomatic) => {
     track2("stream_quality_changed", {
       ...getBaseProps(),
       stream_id: streamId,
@@ -2338,7 +3578,7 @@ function useBalanceLive() {
       is_automatic: isAutomatic
     });
   }, [track2, getBaseProps]);
-  const streamError = useCallback14((streamId, errorCode, errorMessage) => {
+  const streamError = useCallback16((streamId, errorCode, errorMessage) => {
     track2("stream_error", {
       ...getBaseProps(),
       stream_id: streamId,
@@ -2346,7 +3586,7 @@ function useBalanceLive() {
       error_message: errorMessage
     });
   }, [track2, getBaseProps]);
-  const sendChat = useCallback14((streamId, messageLength, hasEmoji) => {
+  const sendChat = useCallback16((streamId, messageLength, hasEmoji) => {
     messageCountRef.current += 1;
     track2("stream_chat_sent", {
       ...getBaseProps(),
@@ -2355,7 +3595,7 @@ function useBalanceLive() {
       has_emoji: hasEmoji
     });
   }, [track2, getBaseProps]);
-  const react = useCallback14((streamId, reactionType) => {
+  const react = useCallback16((streamId, reactionType) => {
     reactionCountRef.current += 1;
     track2("stream_reaction", {
       ...getBaseProps(),
@@ -2363,7 +3603,7 @@ function useBalanceLive() {
       reaction_type: reactionType
     });
   }, [track2, getBaseProps]);
-  const tip = useCallback14((streamId, amount, currency, message) => {
+  const tip = useCallback16((streamId, amount, currency, message) => {
     tipCountRef.current += 1;
     track2("stream_tip", {
       ...getBaseProps(),
@@ -2373,7 +3613,7 @@ function useBalanceLive() {
       has_message: !!message
     });
   }, [track2, getBaseProps]);
-  const gift = useCallback14((streamId, giftType, recipientId, value) => {
+  const gift = useCallback16((streamId, giftType, recipientId, value) => {
     track2("stream_gift", {
       ...getBaseProps(),
       stream_id: streamId,
@@ -2382,7 +3622,7 @@ function useBalanceLive() {
       gift_value: value
     });
   }, [track2, getBaseProps]);
-  const pollVote = useCallback14((streamId, pollId, optionId) => {
+  const pollVote = useCallback16((streamId, pollId, optionId) => {
     track2("stream_poll_vote", {
       ...getBaseProps(),
       stream_id: streamId,
@@ -2390,7 +3630,7 @@ function useBalanceLive() {
       option_id: optionId
     });
   }, [track2, getBaseProps]);
-  const submitQuestion = useCallback14((streamId, questionId, isAnonymous) => {
+  const submitQuestion = useCallback16((streamId, questionId, isAnonymous) => {
     track2("stream_question_submitted", {
       ...getBaseProps(),
       stream_id: streamId,
@@ -2398,35 +3638,35 @@ function useBalanceLive() {
       is_anonymous: isAnonymous
     });
   }, [track2, getBaseProps]);
-  const share = useCallback14((streamId, platform) => {
+  const share = useCallback16((streamId, platform) => {
     track2("stream_shared", {
       ...getBaseProps(),
       stream_id: streamId,
       share_platform: platform
     });
   }, [track2, getBaseProps]);
-  const captureClip = useCallback14((streamId, clipDurationSeconds) => {
+  const captureClip = useCallback16((streamId, clipDurationSeconds) => {
     track2("stream_clip_captured", {
       ...getBaseProps(),
       stream_id: streamId,
       clip_duration_seconds: clipDurationSeconds
     });
   }, [track2, getBaseProps]);
-  const toggleFullscreen = useCallback14((streamId, isFullscreen) => {
+  const toggleFullscreen = useCallback16((streamId, isFullscreen) => {
     track2("stream_fullscreen_toggled", {
       ...getBaseProps(),
       stream_id: streamId,
       is_fullscreen: isFullscreen
     });
   }, [track2, getBaseProps]);
-  const togglePiP = useCallback14((streamId, isPiP) => {
+  const togglePiP = useCallback16((streamId, isPiP) => {
     track2("stream_pip_toggled", {
       ...getBaseProps(),
       stream_id: streamId,
       is_pip: isPiP
     });
   }, [track2, getBaseProps]);
-  const volumeChanged = useCallback14((streamId, volume, isMuted) => {
+  const volumeChanged = useCallback16((streamId, volume, isMuted) => {
     track2("stream_volume_changed", {
       ...getBaseProps(),
       stream_id: streamId,
@@ -2434,7 +3674,7 @@ function useBalanceLive() {
       is_muted: isMuted
     });
   }, [track2, getBaseProps]);
-  const viewerMilestone = useCallback14((streamId, minutesWatched) => {
+  const viewerMilestone = useCallback16((streamId, minutesWatched) => {
     track2("viewer_milestone", {
       ...getBaseProps(),
       stream_id: streamId,
@@ -2470,34 +3710,34 @@ function useBalanceLive() {
 }
 
 // src/react/useBalanceSubscription.ts
-import { useCallback as useCallback15, useRef as useRef13 } from "react";
+import { useCallback as useCallback17, useRef as useRef16 } from "react";
 function useBalanceSubscription() {
   const { track: track2, purchase: purchase2 } = useBalance();
-  const subscriptionCountRef = useRef13(0);
-  const upgradeCountRef = useRef13(0);
-  const downgradeCountRef = useRef13(0);
-  const cancellationCountRef = useRef13(0);
-  const totalRevenueRef = useRef13(0);
-  const getBaseProps = useCallback15(() => ({
+  const subscriptionCountRef = useRef16(0);
+  const upgradeCountRef = useRef16(0);
+  const downgradeCountRef = useRef16(0);
+  const cancellationCountRef = useRef16(0);
+  const totalRevenueRef = useRef16(0);
+  const getBaseProps = useCallback17(() => ({
     session_subscriptions: subscriptionCountRef.current,
     session_upgrades: upgradeCountRef.current,
     session_cancellations: cancellationCountRef.current
   }), []);
-  const getStats = useCallback15(() => ({
+  const getStats = useCallback17(() => ({
     subscriptions: subscriptionCountRef.current,
     upgrades: upgradeCountRef.current,
     downgrades: downgradeCountRef.current,
     cancellations: cancellationCountRef.current,
     totalRevenue: totalRevenueRef.current
   }), []);
-  const reset = useCallback15(() => {
+  const reset = useCallback17(() => {
     subscriptionCountRef.current = 0;
     upgradeCountRef.current = 0;
     downgradeCountRef.current = 0;
     cancellationCountRef.current = 0;
     totalRevenueRef.current = 0;
   }, []);
-  const subscribe = useCallback15((planId, price, currency, interval, metadata) => {
+  const subscribe = useCallback17((planId, price, currency, interval, metadata) => {
     subscriptionCountRef.current += 1;
     totalRevenueRef.current += price;
     purchase2(price, currency, {
@@ -2514,7 +3754,7 @@ function useBalanceSubscription() {
       ...metadata
     });
   }, [track2, purchase2, getBaseProps]);
-  const startTrial = useCallback15((planId, trialDays, willConvertTo) => {
+  const startTrial = useCallback17((planId, trialDays, willConvertTo) => {
     track2("trial_started", {
       ...getBaseProps(),
       plan_id: planId,
@@ -2522,7 +3762,7 @@ function useBalanceSubscription() {
       will_convert_to: willConvertTo
     });
   }, [track2, getBaseProps]);
-  const trialConverted = useCallback15((planId, price, currency) => {
+  const trialConverted = useCallback17((planId, price, currency) => {
     subscriptionCountRef.current += 1;
     totalRevenueRef.current += price;
     purchase2(price, currency, {
@@ -2536,14 +3776,14 @@ function useBalanceSubscription() {
       currency
     });
   }, [track2, purchase2, getBaseProps]);
-  const trialExpired = useCallback15((planId, reason) => {
+  const trialExpired = useCallback17((planId, reason) => {
     track2("trial_expired", {
       ...getBaseProps(),
       plan_id: planId,
       expiry_reason: reason
     });
   }, [track2, getBaseProps]);
-  const upgrade = useCallback15((fromPlanId, toPlanId, priceDifference, currency) => {
+  const upgrade = useCallback17((fromPlanId, toPlanId, priceDifference, currency) => {
     upgradeCountRef.current += 1;
     totalRevenueRef.current += priceDifference;
     track2("subscription_upgraded", {
@@ -2554,7 +3794,7 @@ function useBalanceSubscription() {
       currency
     });
   }, [track2, getBaseProps]);
-  const downgrade = useCallback15((fromPlanId, toPlanId, priceDifference, currency, reason) => {
+  const downgrade = useCallback17((fromPlanId, toPlanId, priceDifference, currency, reason) => {
     downgradeCountRef.current += 1;
     track2("subscription_downgraded", {
       ...getBaseProps(),
@@ -2565,7 +3805,7 @@ function useBalanceSubscription() {
       downgrade_reason: reason
     });
   }, [track2, getBaseProps]);
-  const renewal = useCallback15((planId, price, currency, periodNumber) => {
+  const renewal = useCallback17((planId, price, currency, periodNumber) => {
     totalRevenueRef.current += price;
     purchase2(price, currency, {
       type: "renewal",
@@ -2580,7 +3820,7 @@ function useBalanceSubscription() {
       period_number: periodNumber
     });
   }, [track2, purchase2, getBaseProps]);
-  const cancelInitiated = useCallback15((planId, reason, feedback) => {
+  const cancelInitiated = useCallback17((planId, reason, feedback) => {
     track2("cancellation_initiated", {
       ...getBaseProps(),
       plan_id: planId,
@@ -2588,7 +3828,7 @@ function useBalanceSubscription() {
       feedback: feedback?.slice(0, 500)
     });
   }, [track2, getBaseProps]);
-  const cancel = useCallback15((planId, reason, wasInTrial, periodsCompleted) => {
+  const cancel = useCallback17((planId, reason, wasInTrial, periodsCompleted) => {
     cancellationCountRef.current += 1;
     track2("subscription_canceled", {
       ...getBaseProps(),
@@ -2598,7 +3838,7 @@ function useBalanceSubscription() {
       periods_completed: periodsCompleted
     });
   }, [track2, getBaseProps]);
-  const pause = useCallback15((planId, pauseDurationDays, reason) => {
+  const pause = useCallback17((planId, pauseDurationDays, reason) => {
     track2("subscription_paused", {
       ...getBaseProps(),
       plan_id: planId,
@@ -2606,14 +3846,14 @@ function useBalanceSubscription() {
       pause_reason: reason
     });
   }, [track2, getBaseProps]);
-  const resume = useCallback15((planId, pausedDays) => {
+  const resume = useCallback17((planId, pausedDays) => {
     track2("subscription_resumed", {
       ...getBaseProps(),
       plan_id: planId,
       paused_days: pausedDays
     });
   }, [track2, getBaseProps]);
-  const reactivate = useCallback15((planId, daysSinceCanceled, winbackOffer) => {
+  const reactivate = useCallback17((planId, daysSinceCanceled, winbackOffer) => {
     subscriptionCountRef.current += 1;
     track2("subscription_reactivated", {
       ...getBaseProps(),
@@ -2622,27 +3862,27 @@ function useBalanceSubscription() {
       winback_offer: winbackOffer
     });
   }, [track2, getBaseProps]);
-  const addPaymentMethod = useCallback15((methodType, isDefault) => {
+  const addPaymentMethod = useCallback17((methodType, isDefault) => {
     track2("payment_method_added", {
       ...getBaseProps(),
       method_type: methodType,
       is_default: isDefault
     });
   }, [track2, getBaseProps]);
-  const updatePaymentMethod = useCallback15((oldMethodType, newMethodType) => {
+  const updatePaymentMethod = useCallback17((oldMethodType, newMethodType) => {
     track2("payment_method_updated", {
       ...getBaseProps(),
       old_method_type: oldMethodType,
       new_method_type: newMethodType
     });
   }, [track2, getBaseProps]);
-  const removePaymentMethod = useCallback15((methodType) => {
+  const removePaymentMethod = useCallback17((methodType) => {
     track2("payment_method_removed", {
       ...getBaseProps(),
       method_type: methodType
     });
   }, [track2, getBaseProps]);
-  const paymentFailed = useCallback15((planId, amount, currency, failureReason, attemptNumber) => {
+  const paymentFailed = useCallback17((planId, amount, currency, failureReason, attemptNumber) => {
     track2("payment_failed", {
       ...getBaseProps(),
       plan_id: planId,
@@ -2652,7 +3892,7 @@ function useBalanceSubscription() {
       attempt_number: attemptNumber
     });
   }, [track2, getBaseProps]);
-  const paymentRecovered = useCallback15((planId, amount, currency, daysOverdue) => {
+  const paymentRecovered = useCallback17((planId, amount, currency, daysOverdue) => {
     totalRevenueRef.current += amount;
     track2("payment_recovered", {
       ...getBaseProps(),
@@ -2662,7 +3902,7 @@ function useBalanceSubscription() {
       days_overdue: daysOverdue
     });
   }, [track2, getBaseProps]);
-  const refund = useCallback15((planId, amount, currency, reason, isPartial) => {
+  const refund = useCallback17((planId, amount, currency, reason, isPartial) => {
     totalRevenueRef.current -= amount;
     track2("refund_issued", {
       ...getBaseProps(),
@@ -2673,7 +3913,7 @@ function useBalanceSubscription() {
       is_partial: isPartial
     });
   }, [track2, getBaseProps]);
-  const applyPromo = useCallback15((promoCode, discountPercent, discountAmount, currency) => {
+  const applyPromo = useCallback17((promoCode, discountPercent, discountAmount, currency) => {
     track2("promo_applied", {
       ...getBaseProps(),
       promo_code: promoCode,
@@ -2682,7 +3922,7 @@ function useBalanceSubscription() {
       currency
     });
   }, [track2, getBaseProps]);
-  const giftPurchased = useCallback15((planId, price, currency, recipientType) => {
+  const giftPurchased = useCallback17((planId, price, currency, recipientType) => {
     totalRevenueRef.current += price;
     purchase2(price, currency, {
       type: "gift_subscription",
@@ -2696,7 +3936,7 @@ function useBalanceSubscription() {
       recipient_type: recipientType
     });
   }, [track2, purchase2, getBaseProps]);
-  const giftRedeemed = useCallback15((planId, giftCode) => {
+  const giftRedeemed = useCallback17((planId, giftCode) => {
     subscriptionCountRef.current += 1;
     track2("gift_subscription_redeemed", {
       ...getBaseProps(),
@@ -2704,12 +3944,12 @@ function useBalanceSubscription() {
       gift_code: giftCode
     });
   }, [track2, getBaseProps]);
-  const viewBillingPage = useCallback15(() => {
+  const viewBillingPage = useCallback17(() => {
     track2("billing_page_viewed", {
       ...getBaseProps()
     });
   }, [track2, getBaseProps]);
-  const viewPricingPage = useCallback15((source) => {
+  const viewPricingPage = useCallback17((source) => {
     track2("pricing_page_viewed", {
       ...getBaseProps(),
       source
@@ -2753,15 +3993,15 @@ function useBalanceSubscription() {
 }
 
 // src/react/BalanceAnalytics.tsx
-import React4, { useEffect as useEffect7, useRef as useRef14, Suspense } from "react";
+import React8, { useEffect as useEffect12, useRef as useRef17, Suspense } from "react";
 import { usePathname as usePathname2, useSearchParams } from "next/navigation";
 function BalanceAnalyticsInner() {
   const pathname = usePathname2();
   const searchParams = useSearchParams();
-  const isFirstRender = useRef14(true);
-  const lastTrackedPath = useRef14(null);
+  const isFirstRender = useRef17(true);
+  const lastTrackedPath = useRef17(null);
   const balance = useBalanceOptional();
-  useEffect7(() => {
+  useEffect12(() => {
     if (typeof window === "undefined")
       return;
     const pageTracker = balance?.page ?? window.balance?.page;
@@ -2793,19 +4033,19 @@ function BalanceAnalyticsInner() {
   return null;
 }
 function BalanceAnalytics() {
-  return /* @__PURE__ */ React4.createElement(Suspense, { fallback: null }, /* @__PURE__ */ React4.createElement(BalanceAnalyticsInner, null));
+  return /* @__PURE__ */ React8.createElement(Suspense, { fallback: null }, /* @__PURE__ */ React8.createElement(BalanceAnalyticsInner, null));
 }
 
 // src/react/ConsentBridge.tsx
-import { useEffect as useEffect8, useRef as useRef15 } from "react";
+import { useEffect as useEffect13, useRef as useRef18 } from "react";
 function ConsentBridge({
   analytics,
   marketing,
   personalization
 }) {
   const { setConsent: setConsent2 } = useBalanceConsent();
-  const isInitialized = useRef15(false);
-  useEffect8(() => {
+  const isInitialized = useRef18(false);
+  useEffect13(() => {
     if (analytics === void 0 && marketing === void 0 && personalization === void 0) {
       return;
     }
@@ -2824,7 +4064,7 @@ function ConsentBridge({
 }
 
 // src/react/useBalanceIdentify.ts
-import { useCallback as useCallback16, useEffect as useEffect9, useRef as useRef16 } from "react";
+import { useCallback as useCallback18, useEffect as useEffect14, useRef as useRef19 } from "react";
 
 // src/storage/StorageManager.ts
 var DEFAULT_PREFIX = "balance_";
@@ -3133,10 +4373,10 @@ function checkAnalyticsConsent() {
   }
 }
 function useBalanceIdentify() {
-  const pollIntervalRef = useRef16(null);
-  const hasProcessedPending = useRef16(false);
+  const pollIntervalRef = useRef19(null);
+  const hasProcessedPending = useRef19(false);
   const storageManager = typeof window !== "undefined" ? getStorageManager() : null;
-  const getPendingIdentify = useCallback16(() => {
+  const getPendingIdentify = useCallback18(() => {
     if (!storageManager)
       return null;
     const pending = storageManager.getJSON(PENDING_IDENTIFY_KEY);
@@ -3148,7 +4388,7 @@ function useBalanceIdentify() {
     }
     return pending;
   }, [storageManager]);
-  const setPendingIdentify = useCallback16((email, traits) => {
+  const setPendingIdentify = useCallback18((email, traits) => {
     if (!storageManager)
       return;
     storageManager.setJSON(PENDING_IDENTIFY_KEY, {
@@ -3157,12 +4397,12 @@ function useBalanceIdentify() {
       timestamp: Date.now()
     });
   }, [storageManager]);
-  const clearPendingIdentify = useCallback16(() => {
+  const clearPendingIdentify = useCallback18(() => {
     if (!storageManager)
       return;
     storageManager.removeItem(PENDING_IDENTIFY_KEY);
   }, [storageManager]);
-  const identify2 = useCallback16((email, traits) => {
+  const identify2 = useCallback18((email, traits) => {
     const hasConsent2 = checkAnalyticsConsent();
     if (!hasConsent2) {
       console.log("[useBalanceIdentify] Skipping identify - user declined analytics consent");
@@ -3181,7 +4421,7 @@ function useBalanceIdentify() {
     setPendingIdentify(email, traits);
     return false;
   }, [storageManager, clearPendingIdentify, setPendingIdentify]);
-  const processPendingIdentify = useCallback16(() => {
+  const processPendingIdentify = useCallback18(() => {
     if (hasProcessedPending.current)
       return;
     const pending = getPendingIdentify();
@@ -3204,7 +4444,7 @@ function useBalanceIdentify() {
       hasProcessedPending.current = true;
     }
   }, [getPendingIdentify, clearPendingIdentify, storageManager]);
-  useEffect9(() => {
+  useEffect14(() => {
     processPendingIdentify();
     const pending = getPendingIdentify();
     if (pending && !hasProcessedPending.current) {
@@ -3311,13 +4551,19 @@ var hasConsent = (type) => {
   return window.balance?.hasConsent(type) ?? false;
 };
 export {
+  ArtistOS,
+  BALANCE_TO_C15T_MAP,
   BalanceAnalytics,
   BalanceContext,
   BalanceProvider,
+  C15T_TO_BALANCE_MAP,
+  ConsentBanner,
   ConsentBridge,
+  ConsentDialog,
   DEFAULT_GTM_CONSENT,
   GTMProvider,
   StorageManager,
+  fromBalanceConsent,
   getAttribution,
   getConsent,
   getFanIdHash,
@@ -3329,7 +4575,10 @@ export {
   page,
   purchase,
   setConsent,
+  toBalanceConsent,
   track,
+  useArtistOS,
+  useArtistOSOptional,
   useBalance,
   useBalanceAB,
   useBalanceAuth,
@@ -3347,6 +4596,8 @@ export {
   useBalanceSearch,
   useBalanceSocial,
   useBalanceSubscription,
+  useBuiltInConsent,
+  useC15tConsent,
   useGTMConsent,
   usePageviewTracking
 };