@gurulu/web 1.0.2 → 1.2.0

package/dist/react.js

@@ -0,0 +1,1611 @@
+// src/activation.ts
+function fnv1a32(str) {
+  let h = 2166136261;
+  for (let i = 0;i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function activationBucket(key, uid) {
+  return fnv1a32(`${key}:${uid}`) % 1e4 / 1e4;
+}
+var EMPTY = {
+  workspace_id: "",
+  popups: [],
+  tours: [],
+  personalizations: [],
+  experiments: []
+};
+
+class GuruluActivation {
+  cfg;
+  data = null;
+  pending = null;
+  exposed = new Set;
+  served = new Set;
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  async refresh(opts) {
+    if (this.pending)
+      return this.pending;
+    const f = this.cfg.fetchImpl ?? (typeof fetch !== "undefined" ? fetch.bind(globalThis) : null);
+    if (!f)
+      return EMPTY;
+    const uid = this.cfg.getUid();
+    const sp = new URLSearchParams;
+    if (uid)
+      sp.set("uid", uid);
+    const winHref = typeof window !== "undefined" && window.location ? window.location.href : "";
+    const url = opts?.url ?? winHref;
+    if (url)
+      sp.set("url", url);
+    const ua = typeof navigator !== "undefined" && navigator.userAgent ? navigator.userAgent : "";
+    const device = opts?.device ?? (/Mobi|Android/i.test(ua) ? "mobile" : "desktop");
+    sp.set("device", device);
+    this.pending = (async () => {
+      try {
+        const res = await f(`${this.cfg.endpoint}/v1/activate?${sp.toString()}`, {
+          method: "GET",
+          headers: { Authorization: `Bearer ${this.cfg.workspaceKey}` },
+          credentials: "omit"
+        });
+        if (!res.ok)
+          return this.data ?? EMPTY;
+        this.data = await res.json();
+        return this.data;
+      } catch {
+        return this.data ?? EMPTY;
+      } finally {
+        this.pending = null;
+      }
+    })();
+    return this.pending;
+  }
+  getPopups() {
+    return this.data?.popups ?? [];
+  }
+  getTours() {
+    return this.data?.tours ?? [];
+  }
+  getContent(slot) {
+    const p = (this.data?.personalizations ?? []).find((x) => x.slot_key === slot);
+    if (!p)
+      return null;
+    if (!this.served.has(p.key)) {
+      this.served.add(p.key);
+      this.cfg.track("personalization_served", {
+        personalization_key: p.key,
+        variant_key: p.variant_key,
+        is_holdout: p.is_holdout
+      });
+    }
+    return p.content;
+  }
+  getVariant(experimentKey) {
+    const e = (this.data?.experiments ?? []).find((x) => x.key === experimentKey);
+    if (!e)
+      return null;
+    const variant = e.assigned_variant ?? assignLocalVariant(experimentKey, this.cfg.getUid(), e.variants);
+    if (variant && !this.exposed.has(experimentKey)) {
+      this.exposed.add(experimentKey);
+      this.cfg.track("experiment_exposed", {
+        experiment_key: experimentKey,
+        variant_key: variant
+      });
+    }
+    return variant;
+  }
+  trackPopup(key, action) {
+    this.cfg.track(`popup_${action}`, { popup_key: key });
+  }
+  trackTour(key, action, stepIndex) {
+    this.cfg.track(`tour_${action}`, {
+      tour_key: key,
+      ...stepIndex !== undefined ? { step_index: stepIndex } : {}
+    });
+  }
+  async saveTourProgress(tourKey, body) {}
+  snapshot() {
+    return this.data ?? EMPTY;
+  }
+}
+function assignLocalVariant(key, uid, variants) {
+  const valid = variants.filter((v) => v.weight > 0 && v.key.length > 0);
+  if (valid.length === 0 || !uid)
+    return null;
+  const total = valid.reduce((s, v) => s + v.weight, 0);
+  if (total <= 0)
+    return null;
+  const bucket = activationBucket(key, uid);
+  let cum = 0;
+  for (const v of valid) {
+    cum += v.weight / total;
+    if (bucket < cum)
+      return v.key;
+  }
+  return valid[valid.length - 1].key;
+}
+// src/consent.ts
+var DEFAULT_API_URL = "https://api.gurulu.io";
+var STORAGE_PREFIX = "gurulu_consent_";
+var ANON_STORAGE_KEY = "gurulu_anon_id";
+
+class GuruluConsent {
+  workspaceId;
+  apiUrl;
+  fetchImpl;
+  storage;
+  autoBanner;
+  locale;
+  anonymousIdValue;
+  bannerConfigCache = null;
+  bannerEl = null;
+  constructor(opts) {
+    this.workspaceId = opts.workspaceId;
+    this.apiUrl = (opts.apiUrl ?? DEFAULT_API_URL).replace(/\/+$/, "");
+    this.fetchImpl = opts.fetchImpl ?? (typeof fetch !== "undefined" ? fetch.bind(globalThis) : noFetch);
+    this.storage = opts.storage ?? (typeof globalThis !== "undefined" && "localStorage" in globalThis ? globalThis.localStorage : null);
+    this.autoBanner = opts.autoBanner ?? true;
+    this.locale = opts.locale ?? detectLocale();
+    this.anonymousIdValue = opts.anonymousId ?? this.loadOrCreateAnonId();
+  }
+  async init() {
+    if (typeof window === "undefined")
+      return;
+    try {
+      const res = await this.fetchImpl(`${this.apiUrl}/v1/consent/banner-config?workspace_id=${encodeURIComponent(this.workspaceId)}`, { method: "GET", credentials: "omit" });
+      if (!res.ok)
+        return;
+      this.bannerConfigCache = await res.json();
+    } catch {
+      return;
+    }
+    const local = this.getState();
+    if (!local && this.autoBanner && this.bannerConfigCache?.mode === "banner_required") {
+      this.showBanner();
+    }
+  }
+  getState() {
+    if (!this.storage)
+      return null;
+    try {
+      const raw = this.storage.getItem(this.storageKey());
+      if (!raw)
+        return null;
+      const parsed = JSON.parse(raw);
+      if (parsed.expiresAt && new Date(parsed.expiresAt).getTime() < Date.now()) {
+        this.storage.removeItem(this.storageKey());
+        return null;
+      }
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  async setState(categories) {
+    const current = this.getState()?.categories;
+    const next = {
+      necessary: true,
+      analytics: categories.analytics ?? current?.analytics ?? false,
+      marketing: categories.marketing ?? current?.marketing ?? false,
+      functional: categories.functional ?? current?.functional ?? false,
+      personalization: categories.personalization ?? current?.personalization ?? false
+    };
+    const grantedAt = new Date;
+    const renewalMonths = this.bannerConfigCache?.renewal_months ?? 13;
+    const expiresAt = new Date(grantedAt);
+    expiresAt.setMonth(expiresAt.getMonth() + renewalMonths);
+    const snapshot = {
+      workspaceId: this.workspaceId,
+      anonymousId: this.anonymousIdValue,
+      categories: next,
+      grantedAt: grantedAt.toISOString(),
+      expiresAt: expiresAt.toISOString(),
+      source: "sdk_api"
+    };
+    if (this.storage) {
+      try {
+        this.storage.setItem(this.storageKey(), JSON.stringify(snapshot));
+      } catch {}
+    }
+    try {
+      await this.fetchImpl(`${this.apiUrl}/v1/consent/state`, {
+        method: "POST",
+        credentials: "omit",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          workspace_id: this.workspaceId,
+          anonymous_id: this.anonymousIdValue,
+          necessary: next.necessary,
+          analytics: next.analytics,
+          marketing: next.marketing,
+          functional: next.functional,
+          personalization: next.personalization,
+          source: "sdk_api"
+        })
+      });
+    } catch {}
+  }
+  showBanner() {
+    if (typeof document === "undefined")
+      return;
+    if (this.bannerEl)
+      return;
+    const cfg = this.bannerConfigCache?.banner_config ?? {};
+    const text = this.bannerText();
+    const accentColor = cfg.brand?.primary_color ?? "#fafafa";
+    const position = cfg.position ?? "bottom";
+    const el = document.createElement("div");
+    el.setAttribute("data-gurulu-consent-banner", "");
+    el.setAttribute("role", "dialog");
+    el.setAttribute("aria-label", text.heading);
+    el.style.cssText = bannerCss(position);
+    el.innerHTML = bannerHtml(text, accentColor);
+    const acceptBtn = el.querySelector("[data-gurulu-accept]");
+    const rejectBtn = el.querySelector("[data-gurulu-reject]");
+    acceptBtn?.addEventListener("click", () => {
+      this.setState({
+        analytics: true,
+        marketing: true,
+        functional: true,
+        personalization: true
+      });
+      this.hideBanner();
+    });
+    rejectBtn?.addEventListener("click", () => {
+      this.setState({
+        analytics: false,
+        marketing: false,
+        functional: false,
+        personalization: false
+      });
+      this.hideBanner();
+    });
+    document.body.appendChild(el);
+    this.bannerEl = el;
+  }
+  hideBanner() {
+    if (this.bannerEl?.parentNode) {
+      this.bannerEl.parentNode.removeChild(this.bannerEl);
+    }
+    this.bannerEl = null;
+  }
+  buildIngestHeader() {
+    const snap = this.getState();
+    if (!snap)
+      return JSON.stringify({ necessary: true });
+    return JSON.stringify(snap.categories);
+  }
+  getAnonymousId() {
+    return this.anonymousIdValue;
+  }
+  storageKey() {
+    return `${STORAGE_PREFIX}${this.workspaceId}`;
+  }
+  loadOrCreateAnonId() {
+    if (!this.storage)
+      return generateAnonId();
+    try {
+      const existing = this.storage.getItem(ANON_STORAGE_KEY);
+      if (existing)
+        return existing;
+      const fresh = generateAnonId();
+      this.storage.setItem(ANON_STORAGE_KEY, fresh);
+      return fresh;
+    } catch {
+      return generateAnonId();
+    }
+  }
+  bannerText() {
+    const cfg = this.bannerConfigCache?.banner_config;
+    const localeOverride = cfg?.text_overrides?.[this.locale];
+    if (this.locale === "tr") {
+      return {
+        heading: localeOverride?.heading ?? "Çerezleri tercih et",
+        body: localeOverride?.body ?? "Deneyimini iyileştirmek için analytics + pazarlama çerezleri kullanıyoruz.",
+        accept: localeOverride?.accept ?? "Tümünü kabul et",
+        reject: localeOverride?.reject ?? "Sadece gerekli olanlar"
+      };
+    }
+    return {
+      heading: localeOverride?.heading ?? "Manage cookies",
+      body: localeOverride?.body ?? "We use analytics and marketing cookies to improve your experience.",
+      accept: localeOverride?.accept ?? "Accept all",
+      reject: localeOverride?.reject ?? "Necessary only"
+    };
+  }
+}
+function bannerCss(position) {
+  const base = "position:fixed;z-index:2147483647;background:#141414;color:#fafafa;border:1px solid #262626;border-radius:8px;padding:16px;font-family:-apple-system,Segoe UI,Roboto,sans-serif;font-size:14px;line-height:1.5;box-shadow:0 4px 24px rgba(0,0,0,0.4);max-width:480px;";
+  switch (position) {
+    case "top":
+      return `${base}top:16px;left:50%;transform:translateX(-50%);`;
+    case "bottom-left":
+      return `${base}bottom:16px;left:16px;`;
+    case "bottom-right":
+      return `${base}bottom:16px;right:16px;`;
+    case "modal":
+      return `${base}top:50%;left:50%;transform:translate(-50%,-50%);`;
+    default:
+      return `${base}bottom:16px;left:50%;transform:translateX(-50%);`;
+  }
+}
+function bannerHtml(text, accent) {
+  return `
+    <div style="margin-bottom:12px;font-weight:600;">${escapeHtml(text.heading)}</div>
+    <div style="margin-bottom:16px;color:#a3a3a3;">${escapeHtml(text.body)}</div>
+    <div style="display:flex;gap:8px;flex-wrap:wrap;">
+      <button data-gurulu-accept type="button" style="background:${escapeAttr(accent)};color:#0a0a0a;border:none;padding:8px 16px;border-radius:6px;font-weight:600;cursor:pointer;">${escapeHtml(text.accept)}</button>
+      <button data-gurulu-reject type="button" style="background:transparent;color:#fafafa;border:1px solid #404040;padding:8px 16px;border-radius:6px;cursor:pointer;">${escapeHtml(text.reject)}</button>
+    </div>
+  `;
+}
+function escapeHtml(s) {
+  return s.replace(/[&<>"']/g, (c) => {
+    switch (c) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      case "'":
+        return "&#39;";
+      default:
+        return c;
+    }
+  });
+}
+function escapeAttr(s) {
+  return s.replace(/[^a-zA-Z0-9#()_\-., ]/g, "");
+}
+function detectLocale() {
+  if (typeof navigator === "undefined")
+    return "en";
+  const lang = (navigator.language ?? "").toLowerCase();
+  if (lang.startsWith("tr"))
+    return "tr";
+  if (lang.startsWith("zh"))
+    return "zh";
+  if (lang.startsWith("ar"))
+    return "ar";
+  return "en";
+}
+function generateAnonId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return `anon_${crypto.randomUUID()}`;
+  }
+  return `anon_${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+}
+async function noFetch() {
+  throw new Error("fetch not available — provide opts.fetchImpl");
+}
+// src/autocapture/click.ts
+var CLICKABLE_TAGS = new Set(["A", "BUTTON"]);
+var DOWNLOAD_EXT = /\.(pdf|zip|dmg|exe|tar|gz|rar|7z|mp3|mp4|csv|xlsx?|docx?|pptx?)(\?|$)/i;
+function isTrackable(el) {
+  let node = el;
+  while (node) {
+    if (node.hasAttribute?.("data-gurulu-no-track"))
+      return false;
+    node = node.parentElement;
+  }
+  return true;
+}
+function findClickable(target) {
+  let node = target;
+  while (node) {
+    if (!node.tagName) {
+      node = node.parentElement;
+      continue;
+    }
+    if (CLICKABLE_TAGS.has(node.tagName))
+      return node;
+    if (node.getAttribute?.("role") === "button")
+      return node;
+    if (node.tagName === "INPUT") {
+      const t = node.type?.toLowerCase();
+      if (t === "submit" || t === "button")
+        return node;
+    }
+    node = node.parentElement;
+  }
+  return null;
+}
+function readCustomProps(el) {
+  const out = {};
+  if (!el.attributes)
+    return out;
+  for (let i = 0;i < el.attributes.length; i += 1) {
+    const attr = el.attributes.item(i);
+    if (!attr)
+      continue;
+    if (attr.name.startsWith("data-gurulu-prop-")) {
+      const k = attr.name.slice("data-gurulu-prop-".length);
+      out[k] = attr.value;
+    }
+  }
+  return out;
+}
+function startClickAutocapture(track) {
+  if (typeof document === "undefined")
+    return { stop: () => {
+      return;
+    } };
+  const handler = (ev) => {
+    const found = findClickable(ev.target);
+    if (!found || !isTrackable(found))
+      return;
+    const payload = {
+      element_tag: found.tagName.toLowerCase()
+    };
+    if (found.id)
+      payload.element_id = found.id;
+    if (found.className && typeof found.className === "string") {
+      payload.element_class = found.className.slice(0, 256);
+    }
+    const text = (found.textContent ?? "").trim().slice(0, 200);
+    if (text)
+      payload.element_text = text;
+    if (found.tagName === "A") {
+      const href = found.href;
+      if (href) {
+        payload.href = href;
+        try {
+          const host = new URL(href).hostname;
+          if (typeof window !== "undefined" && host !== window.location.hostname) {
+            payload.is_outbound = true;
+          }
+        } catch {}
+        if (DOWNLOAD_EXT.test(href))
+          payload.is_download = true;
+      }
+    }
+    const customEvent = found.getAttribute?.("data-gurulu-event");
+    if (customEvent) {
+      payload.custom_event = customEvent;
+      payload.custom_props = readCustomProps(found);
+    }
+    track(payload);
+  };
+  document.addEventListener("click", handler, true);
+  return {
+    stop() {
+      document.removeEventListener("click", handler, true);
+    }
+  };
+}
+
+// src/autocapture/error.ts
+var MAX_STACK = 2000;
+var MAX_MESSAGE = 1000;
+function startErrorAutocapture(track) {
+  if (typeof window === "undefined")
+    return { stop: () => {
+      return;
+    } };
+  const onError = (ev) => {
+    const err = ev.error;
+    track({
+      message: String(ev.message ?? err?.message ?? "Error").slice(0, MAX_MESSAGE),
+      error_type: err?.name ?? "Error",
+      ...ev.filename ? { source: ev.filename } : {},
+      ...typeof ev.lineno === "number" ? { lineno: ev.lineno } : {},
+      ...typeof ev.colno === "number" ? { colno: ev.colno } : {},
+      ...err?.stack ? { stack: String(err.stack).slice(0, MAX_STACK) } : {}
+    });
+  };
+  const onRejection = (ev) => {
+    const reason = ev.reason;
+    const isErr = reason instanceof Error;
+    track({
+      message: String(isErr ? reason.message : reason).slice(0, MAX_MESSAGE),
+      error_type: isErr ? reason.name : "UnhandledRejection",
+      ...isErr && reason.stack ? { stack: String(reason.stack).slice(0, MAX_STACK) } : {}
+    });
+  };
+  window.addEventListener("error", onError);
+  window.addEventListener("unhandledrejection", onRejection);
+  return {
+    stop() {
+      window.removeEventListener("error", onError);
+      window.removeEventListener("unhandledrejection", onRejection);
+    }
+  };
+}
+
+// src/autocapture/form.ts
+var SENSITIVE_INPUT_TYPES = new Set(["password", "tel"]);
+function isSensitiveField(el) {
+  if (el.tagName !== "INPUT")
+    return false;
+  const input = el;
+  const type = (input.type ?? "").toLowerCase();
+  if (SENSITIVE_INPUT_TYPES.has(type))
+    return true;
+  const autocomplete = (input.autocomplete ?? "").toLowerCase();
+  if (autocomplete.startsWith("cc-"))
+    return true;
+  return false;
+}
+function isTrackable2(el) {
+  let node = el;
+  while (node) {
+    if (node.hasAttribute?.("data-gurulu-no-track"))
+      return false;
+    node = node.parentElement;
+  }
+  return true;
+}
+function findForm(target) {
+  let node = target;
+  while (node) {
+    if (node.tagName === "FORM")
+      return node;
+    node = node.parentElement;
+  }
+  return null;
+}
+function formMeta(form) {
+  const out = {
+    count: form.elements?.length ?? 0
+  };
+  if (form.id)
+    out.id = form.id;
+  if (form.name)
+    out.name = form.name;
+  return out;
+}
+function startFormAutocapture(track) {
+  if (typeof document === "undefined")
+    return { stop: () => {
+      return;
+    } };
+  const startedForms = new WeakSet;
+  const onFocus = (ev) => {
+    const t = ev.target;
+    if (!t)
+      return;
+    if (isSensitiveField(t))
+      return;
+    if (!isTrackable2(t))
+      return;
+    const form = findForm(t);
+    if (!form || startedForms.has(form))
+      return;
+    startedForms.add(form);
+    const meta = formMeta(form);
+    const p = { field_count: meta.count };
+    if (meta.id)
+      p.form_id = meta.id;
+    if (meta.name)
+      p.form_name = meta.name;
+    track.onStart(p);
+  };
+  const onSubmit = (ev) => {
+    const form = ev.target;
+    if (!form || form.tagName !== "FORM")
+      return;
+    if (!isTrackable2(form))
+      return;
+    const meta = formMeta(form);
+    const filled = [];
+    const els = form.elements;
+    for (let i = 0;i < els.length; i += 1) {
+      const el = els[i];
+      if (!el)
+        continue;
+      if (isSensitiveField(el))
+        continue;
+      if (!("value" in el))
+        continue;
+      if (typeof el.value === "string" && el.value.length > 0 && el.name) {
+        filled.push(el.name);
+      }
+    }
+    const p = { field_count: meta.count };
+    if (meta.id)
+      p.form_id = meta.id;
+    if (meta.name)
+      p.form_name = meta.name;
+    if (filled.length > 0)
+      p.filled_fields = filled;
+    track.onSubmit(p);
+  };
+  document.addEventListener("focus", onFocus, true);
+  document.addEventListener("submit", onSubmit, true);
+  return {
+    stop() {
+      document.removeEventListener("focus", onFocus, true);
+      document.removeEventListener("submit", onSubmit, true);
+    }
+  };
+}
+
+// src/autocapture/page.ts
+function startPageAutocapture(track) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return { stop: () => {
+      return;
+    } };
+  }
+  let lastPath = window.location.pathname + window.location.search;
+  function emit() {
+    const current = window.location.pathname + window.location.search;
+    if (current === lastPath)
+      return;
+    lastPath = current;
+    track(window.location.href, document.title, document.referrer);
+  }
+  track(window.location.href, document.title, document.referrer);
+  const onPop = () => emit();
+  window.addEventListener("popstate", onPop);
+  const origPush = history.pushState.bind(history);
+  const origReplace = history.replaceState.bind(history);
+  history.pushState = function patchedPush(...args) {
+    const ret = origPush(...args);
+    queueMicrotask(emit);
+    return ret;
+  };
+  history.replaceState = function patchedReplace(...args) {
+    const ret = origReplace(...args);
+    queueMicrotask(emit);
+    return ret;
+  };
+  return {
+    stop() {
+      window.removeEventListener("popstate", onPop);
+      history.pushState = origPush;
+      history.replaceState = origReplace;
+    }
+  };
+}
+
+// src/autocapture/scroll.ts
+var THRESHOLDS = [25, 50, 75, 90];
+function startScrollAutocapture(track) {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return { stop: () => {
+      return;
+    } };
+  }
+  const fired = new Set;
+  let raf = 0;
+  const compute = () => {
+    raf = 0;
+    const doc = document.documentElement;
+    const body = document.body;
+    if (!doc || !body)
+      return;
+    const scrollTop = window.scrollY ?? doc.scrollTop ?? 0;
+    const viewport = window.innerHeight ?? doc.clientHeight ?? 0;
+    const docHeight = Math.max(body.scrollHeight ?? 0, doc.scrollHeight ?? 0);
+    if (docHeight <= viewport)
+      return;
+    const percent = (scrollTop + viewport) / docHeight * 100;
+    for (const t of THRESHOLDS) {
+      if (percent >= t && !fired.has(t)) {
+        fired.add(t);
+        track({ depth_percent: t });
+      }
+    }
+  };
+  const onScroll = () => {
+    if (raf !== 0)
+      return;
+    raf = requestAnimationFrame(compute);
+  };
+  window.addEventListener("scroll", onScroll, { passive: true });
+  return {
+    stop() {
+      window.removeEventListener("scroll", onScroll);
+      if (raf !== 0)
+        cancelAnimationFrame(raf);
+    }
+  };
+}
+
+// src/autocapture/web-vitals.ts
+var RATINGS = {
+  LCP: [2500, 4000],
+  FID: [100, 300],
+  INP: [200, 500],
+  CLS: [0.1, 0.25],
+  TTFB: [800, 1800],
+  FCP: [1800, 3000]
+};
+function rate(metric, value) {
+  const [good, poor] = RATINGS[metric];
+  if (value <= good)
+    return "good";
+  if (value <= poor)
+    return "needs-improvement";
+  return "poor";
+}
+function safeObserve(entryType, buffered, cb) {
+  if (typeof PerformanceObserver === "undefined")
+    return null;
+  try {
+    const po = new PerformanceObserver((list) => cb(list.getEntries()));
+    po.observe({ type: entryType, buffered });
+    return po;
+  } catch {
+    return null;
+  }
+}
+function startWebVitalsAutocapture(track) {
+  if (typeof window === "undefined")
+    return { stop: () => {
+      return;
+    } };
+  const observers = [];
+  try {
+    const nav = performance.getEntriesByType("navigation")[0];
+    if (nav && nav.responseStart > 0) {
+      track({ metric: "TTFB", value: nav.responseStart, rating: rate("TTFB", nav.responseStart) });
+    }
+    const fcp = performance.getEntriesByName("first-contentful-paint")[0];
+    if (fcp) {
+      track({ metric: "FCP", value: fcp.startTime, rating: rate("FCP", fcp.startTime) });
+    }
+  } catch {}
+  let lastLcp = 0;
+  const lcpPo = safeObserve("largest-contentful-paint", true, (entries) => {
+    const last = entries[entries.length - 1];
+    if (last)
+      lastLcp = last.startTime;
+  });
+  if (lcpPo)
+    observers.push(lcpPo);
+  const fidPo = safeObserve("first-input", true, (entries) => {
+    const first = entries[0];
+    if (first) {
+      const value = first.processingStart - first.startTime;
+      track({ metric: "FID", value, rating: rate("FID", value) });
+    }
+  });
+  if (fidPo)
+    observers.push(fidPo);
+  let worstInp = 0;
+  const eventPo = safeObserve("event", true, (entries) => {
+    for (const e of entries) {
+      const dur = e.duration;
+      if (dur > worstInp)
+        worstInp = dur;
+    }
+  });
+  if (eventPo)
+    observers.push(eventPo);
+  let cls = 0;
+  const clsPo = safeObserve("layout-shift", true, (entries) => {
+    for (const e of entries) {
+      const ls = e;
+      if (!ls.hadRecentInput)
+        cls += ls.value;
+    }
+  });
+  if (clsPo)
+    observers.push(clsPo);
+  const flush = () => {
+    if (lastLcp > 0)
+      track({ metric: "LCP", value: lastLcp, rating: rate("LCP", lastLcp) });
+    if (worstInp > 0)
+      track({ metric: "INP", value: worstInp, rating: rate("INP", worstInp) });
+    if (cls > 0)
+      track({ metric: "CLS", value: cls, rating: rate("CLS", cls) });
+    lastLcp = 0;
+    worstInp = 0;
+    cls = 0;
+  };
+  let onHidden = null;
+  let onPagehide = null;
+  if (typeof document !== "undefined") {
+    onHidden = () => {
+      if (document.visibilityState === "hidden")
+        flush();
+    };
+    onPagehide = flush;
+    document.addEventListener("visibilitychange", onHidden);
+    window.addEventListener("pagehide", onPagehide);
+  }
+  return {
+    stop() {
+      for (const po of observers) {
+        try {
+          po.disconnect();
+        } catch {}
+      }
+      if (typeof document !== "undefined" && onHidden) {
+        document.removeEventListener("visibilitychange", onHidden);
+      }
+      if (typeof window !== "undefined" && onPagehide) {
+        window.removeEventListener("pagehide", onPagehide);
+      }
+    }
+  };
+}
+
+// src/autocapture/index.ts
+var DEFAULTS = {
+  page_view: true,
+  click: true,
+  form_started: true,
+  form_submitted: true,
+  scroll_depth: true,
+  web_vitals: true,
+  outbound_link_click: true,
+  download_click: true,
+  js_error: false,
+  console_error: false,
+  network_error: false
+};
+function startAutocapture(cfg, sinks) {
+  if (cfg === false)
+    return { stopAll: () => {
+      return;
+    } };
+  const merged = { ...DEFAULTS, ...cfg ?? {} };
+  const handles = [];
+  if (merged.page_view)
+    handles.push(startPageAutocapture(sinks.pageView));
+  if (merged.click)
+    handles.push(startClickAutocapture(sinks.click));
+  if (merged.form_started || merged.form_submitted) {
+    handles.push(startFormAutocapture({
+      onStart: merged.form_started ? sinks.formStarted : () => {
+        return;
+      },
+      onSubmit: merged.form_submitted ? sinks.formSubmitted : () => {
+        return;
+      }
+    }));
+  }
+  if (merged.scroll_depth)
+    handles.push(startScrollAutocapture(sinks.scrollDepth));
+  if (merged.web_vitals)
+    handles.push(startWebVitalsAutocapture(sinks.webVital));
+  if (merged.js_error)
+    handles.push(startErrorAutocapture(sinks.jsError));
+  return {
+    stopAll() {
+      for (const h of handles) {
+        try {
+          h.stop();
+        } catch {}
+      }
+    }
+  };
+}
+
+// src/identity.ts
+var ANON_KEY = "gurulu_aid";
+var ANON_COOKIE = "gurulu_aid_mirror";
+var PERSON_KEY = "gurulu_pid";
+function hasWindow() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function uuid() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function readLocalStorage(key) {
+  if (!hasWindow())
+    return null;
+  try {
+    return window.localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function writeLocalStorage(key, value) {
+  if (!hasWindow())
+    return;
+  try {
+    window.localStorage.setItem(key, value);
+  } catch {}
+}
+function deleteLocalStorage(key) {
+  if (!hasWindow())
+    return;
+  try {
+    window.localStorage.removeItem(key);
+  } catch {}
+}
+function readCookie(name) {
+  if (!hasWindow())
+    return null;
+  const cookieStr = document.cookie ?? "";
+  for (const part of cookieStr.split(";")) {
+    const [k, v] = part.trim().split("=");
+    if (k === name && v !== undefined)
+      return decodeURIComponent(v);
+  }
+  return null;
+}
+function writeCookie(name, value, days = 365) {
+  if (!hasWindow())
+    return;
+  const expires = new Date(Date.now() + days * 86400000).toUTCString();
+  const host = window.location.hostname;
+  const parts = host.split(".");
+  const domain = parts.length >= 2 ? `.${parts.slice(-2).join(".")}` : host;
+  try {
+    document.cookie = `${name}=${encodeURIComponent(value)}; path=/; domain=${domain}; expires=${expires}; SameSite=Lax`;
+  } catch {}
+}
+function getOrCreateAnonymousId() {
+  const existing = readLocalStorage(ANON_KEY) ?? readCookie(ANON_COOKIE);
+  if (existing) {
+    writeLocalStorage(ANON_KEY, existing);
+    writeCookie(ANON_COOKIE, existing);
+    return existing;
+  }
+  const fresh = uuid();
+  writeLocalStorage(ANON_KEY, fresh);
+  writeCookie(ANON_COOKIE, fresh);
+  return fresh;
+}
+function setPersonId(personId) {
+  writeLocalStorage(PERSON_KEY, personId);
+}
+function getPersonId() {
+  return readLocalStorage(PERSON_KEY);
+}
+function clearIdentity() {
+  deleteLocalStorage(PERSON_KEY);
+  deleteLocalStorage(ANON_KEY);
+  const fresh = uuid();
+  writeLocalStorage(ANON_KEY, fresh);
+  writeCookie(ANON_COOKIE, fresh);
+  return fresh;
+}
+function newEventId() {
+  return uuid();
+}
+
+// src/errors.ts
+class SDKError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "SDKError";
+  }
+}
+
+class InitError extends SDKError {
+  constructor(message) {
+    super("SDK_INIT", message);
+    this.name = "InitError";
+  }
+}
+
+class NetworkError extends SDKError {
+  status;
+  constructor(message, status) {
+    super("SDK_NETWORK", message);
+    this.name = "NetworkError";
+    if (status !== undefined)
+      this.status = status;
+  }
+}
+
+class QueueFullError extends SDKError {
+  constructor(message) {
+    super("SDK_QUEUE_FULL", message);
+    this.name = "QueueFullError";
+  }
+}
+
+class OptedOutError extends SDKError {
+  constructor() {
+    super("SDK_OPTED_OUT", "tracking disabled — gurulu.optOut() in effect");
+    this.name = "OptedOutError";
+  }
+}
+
+class ConsentBlockedError extends SDKError {
+  constructor() {
+    super("SDK_CONSENT_BLOCKED", "event queued — awaiting consent grant");
+    this.name = "ConsentBlockedError";
+  }
+}
+
+// src/transport.ts
+var BEACON_SIZE_LIMIT = 65536;
+function buildHeaders(cfg, extra) {
+  const h = new Headers({
+    "content-type": "application/json",
+    authorization: `Bearer ${cfg.workspaceKey}`,
+    "x-gurulu-sdk": `@gurulu/web@${cfg.sdkVersion}`
+  });
+  if (extra) {
+    for (const [k, v] of Object.entries(extra))
+      h.set(k, v);
+  }
+  return h;
+}
+async function sendBatch(cfg, body, extraHeaders) {
+  const f = cfg.fetchImpl ?? (typeof fetch !== "undefined" ? fetch.bind(globalThis) : null);
+  if (!f)
+    throw new NetworkError("fetch unavailable");
+  const url = `${cfg.endpoint}/v1/ingest/batch`;
+  const res = await f(url, {
+    method: "POST",
+    keepalive: true,
+    credentials: "omit",
+    headers: buildHeaders(cfg, extraHeaders),
+    body: JSON.stringify(body)
+  });
+  if (!res.ok)
+    throw new NetworkError(`ingest ${res.status}`, res.status);
+}
+function sendBeaconBatch(cfg, body) {
+  if (typeof navigator === "undefined" || typeof navigator.sendBeacon !== "function")
+    return false;
+  const url = `${cfg.endpoint}/v1/ingest/batch?wk=${encodeURIComponent(cfg.workspaceKey)}&sdk=${encodeURIComponent(cfg.sdkVersion)}`;
+  try {
+    const payload = JSON.stringify(body);
+    if (payload.length >= BEACON_SIZE_LIMIT)
+      return false;
+    const blob = new Blob([payload], { type: "application/json" });
+    return navigator.sendBeacon(url, blob);
+  } catch {
+    return false;
+  }
+}
+async function sendIdentify(cfg, body) {
+  const f = cfg.fetchImpl ?? (typeof fetch !== "undefined" ? fetch.bind(globalThis) : null);
+  if (!f)
+    throw new NetworkError("fetch unavailable");
+  const res = await f(`${cfg.endpoint}/v1/ingest/identify`, {
+    method: "POST",
+    keepalive: true,
+    credentials: "omit",
+    headers: buildHeaders(cfg),
+    body: JSON.stringify(body)
+  });
+  if (!res.ok)
+    throw new NetworkError(`identify ${res.status}`, res.status);
+}
+
+// src/queue.ts
+var QUEUE_KEY = "gurulu_queue";
+function hasWindow2() {
+  return typeof window !== "undefined";
+}
+function loadPersisted() {
+  if (!hasWindow2())
+    return [];
+  try {
+    const raw = window.localStorage.getItem(QUEUE_KEY);
+    if (!raw)
+      return [];
+    const arr = JSON.parse(raw);
+    return Array.isArray(arr) ? arr : [];
+  } catch {
+    return [];
+  }
+}
+function persist(events) {
+  if (!hasWindow2())
+    return;
+  try {
+    if (events.length === 0)
+      window.localStorage.removeItem(QUEUE_KEY);
+    else
+      window.localStorage.setItem(QUEUE_KEY, JSON.stringify(events));
+  } catch {}
+}
+
+class EventQueue {
+  opts;
+  buffer;
+  timer = null;
+  flushing = false;
+  constructor(opts) {
+    this.opts = opts;
+    this.buffer = loadPersisted();
+    this.scheduleNext();
+    this.installUnloadHooks();
+    if (this.buffer.length > 0)
+      this.scheduleImmediate();
+  }
+  enqueue(event) {
+    this.buffer.push(event);
+    persist(this.buffer);
+    if (this.buffer.length >= this.opts.maxQueueSize) {
+      this.flush();
+    } else {
+      this.scheduleNext();
+    }
+  }
+  size() {
+    return this.buffer.length;
+  }
+  async flush() {
+    if (this.flushing || this.buffer.length === 0)
+      return;
+    this.flushing = true;
+    const batch = this.buffer.slice(0);
+    try {
+      await this.sendWithRetry(batch);
+      this.buffer = this.buffer.slice(batch.length);
+      persist(this.buffer);
+    } catch (err) {
+      if (this.opts.debug && typeof console !== "undefined") {
+        console.warn("[gurulu] flush failed, retain queue", err);
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+  flushBeacon() {
+    if (this.buffer.length === 0)
+      return;
+    const sent = sendBeaconBatch(this.opts.transport, { events: this.buffer });
+    if (sent) {
+      this.buffer = [];
+      persist(this.buffer);
+    }
+  }
+  scheduleNext() {
+    if (this.timer !== null)
+      return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.flush();
+    }, this.opts.flushIntervalMs);
+  }
+  scheduleImmediate() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.flush();
+    }, 50);
+  }
+  async sendWithRetry(batch) {
+    let attempt = 0;
+    const max = 3;
+    while (attempt < max) {
+      try {
+        await sendBatch(this.opts.transport, { events: batch });
+        return;
+      } catch (err) {
+        attempt += 1;
+        if (attempt >= max)
+          throw err;
+        const backoff = 2 ** attempt * 1000;
+        await new Promise((r) => setTimeout(r, backoff));
+      }
+    }
+  }
+  installUnloadHooks() {
+    if (!hasWindow2() || typeof document === "undefined")
+      return;
+    const onHidden = () => {
+      if (document.visibilityState === "hidden")
+        this.flushBeacon();
+    };
+    try {
+      document.addEventListener("visibilitychange", onHidden);
+      window.addEventListener("pagehide", () => this.flushBeacon());
+    } catch {}
+  }
+}
+
+// src/session.ts
+var SESSION_KEY = "gurulu_sid";
+var SESSION_STARTED_KEY = "gurulu_session_started_at";
+var LAST_EVENT_KEY = "gurulu_last_event_at";
+var FIRST_SOURCE_KEY = "gurulu_first_source";
+var SESSION_TIMEOUT_MS = 30 * 60 * 1000;
+function hasWindow3() {
+  return typeof window !== "undefined";
+}
+function uuid2() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function readLs(key) {
+  if (!hasWindow3())
+    return null;
+  try {
+    return window.localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function writeLs(key, value) {
+  if (!hasWindow3())
+    return;
+  try {
+    window.localStorage.setItem(key, value);
+  } catch {}
+}
+function resolveSession(now = Date.now()) {
+  const existing = readLs(SESSION_KEY);
+  const startedAt = Number(readLs(SESSION_STARTED_KEY) ?? "0");
+  const lastEvent = Number(readLs(LAST_EVENT_KEY) ?? "0");
+  if (existing && startedAt && now - lastEvent < SESSION_TIMEOUT_MS) {
+    writeLs(LAST_EVENT_KEY, String(now));
+    return { session_id: existing, session_started_at: startedAt, is_new: false };
+  }
+  const fresh = uuid2();
+  writeLs(SESSION_KEY, fresh);
+  writeLs(SESSION_STARTED_KEY, String(now));
+  writeLs(LAST_EVENT_KEY, String(now));
+  return { session_id: fresh, session_started_at: now, is_new: true };
+}
+function parseUrlContext(href, referrer) {
+  const utm = {};
+  const clickId = {};
+  if (!href)
+    return { utm, click_id: clickId };
+  let url;
+  try {
+    url = new URL(href);
+  } catch {
+    return { utm, click_id: clickId };
+  }
+  const p = url.searchParams;
+  const s = p.get("utm_source");
+  if (s)
+    utm.source = s;
+  const m = p.get("utm_medium");
+  if (m)
+    utm.medium = m;
+  const c = p.get("utm_campaign");
+  if (c)
+    utm.campaign = c;
+  const t = p.get("utm_term");
+  if (t)
+    utm.term = t;
+  const ct = p.get("utm_content");
+  if (ct)
+    utm.content = ct;
+  const gclid = p.get("gclid");
+  if (gclid)
+    clickId.gclid = gclid;
+  const fbclid = p.get("fbclid");
+  if (fbclid)
+    clickId.fbclid = fbclid;
+  const ttclid = p.get("ttclid");
+  if (ttclid)
+    clickId.ttclid = ttclid;
+  const li = p.get("li_fat_id");
+  if (li)
+    clickId.li_fat_id = li;
+  return { utm, click_id: clickId };
+}
+function preserveFirstSource(touch) {
+  if (readLs(FIRST_SOURCE_KEY))
+    return;
+  writeLs(FIRST_SOURCE_KEY, JSON.stringify(touch));
+}
+function getFirstSource() {
+  const raw = readLs(FIRST_SOURCE_KEY);
+  if (!raw)
+    return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// src/core.ts
+var SDK_VERSION = "0.1.0";
+var DEFAULT_ENDPOINT = "https://ingest.gurulu.io";
+var DEFAULT_API_URL2 = "https://api.gurulu.io";
+var OPT_OUT_KEY = "gurulu_opt_out";
+function isOptedOut() {
+  if (typeof window === "undefined")
+    return false;
+  try {
+    return window.localStorage.getItem(OPT_OUT_KEY) === "1";
+  } catch {
+    return false;
+  }
+}
+function setOptOut(flag) {
+  if (typeof window === "undefined")
+    return;
+  try {
+    if (flag)
+      window.localStorage.setItem(OPT_OUT_KEY, "1");
+    else
+      window.localStorage.removeItem(OPT_OUT_KEY);
+  } catch {}
+}
+function nowIso() {
+  return new Date().toISOString();
+}
+
+class Gurulu {
+  initialized = false;
+  opts = null;
+  queue = null;
+  session = null;
+  anonymousId = null;
+  autocaptureHandle = null;
+  testMode = false;
+  consent;
+  activation;
+  init(opts) {
+    if (this.initialized) {
+      if (opts.debug && typeof console !== "undefined") {
+        console.warn("[gurulu] init() already called — ignoring");
+      }
+      return;
+    }
+    if (typeof window === "undefined")
+      return;
+    this.opts = opts;
+    this.testMode = opts.test_mode === true;
+    this.anonymousId = getOrCreateAnonymousId();
+    this.session = resolveSession();
+    this.consent = new GuruluConsent({
+      workspaceId: opts.workspaceKey,
+      apiUrl: opts.apiUrl ?? DEFAULT_API_URL2,
+      anonymousId: this.anonymousId,
+      autoBanner: opts.consent_mode === "banner_required"
+    });
+    this.consent.init();
+    this.activation = new GuruluActivation({
+      endpoint: opts.endpoint ?? DEFAULT_ENDPOINT,
+      workspaceKey: opts.workspaceKey,
+      getUid: () => getPersonId() ?? this.anonymousId ?? "",
+      track: (key, props) => this.track(key, props)
+    });
+    const transport = {
+      endpoint: opts.endpoint ?? DEFAULT_ENDPOINT,
+      workspaceKey: opts.workspaceKey,
+      sdkVersion: SDK_VERSION
+    };
+    this.queue = new EventQueue({
+      transport,
+      flushIntervalMs: opts.flush_interval_ms ?? 5000,
+      maxQueueSize: opts.max_queue_size ?? 50,
+      ...opts.debug ? { debug: true } : {}
+    });
+    const ctx = parseUrlContext(window.location.href, document.referrer);
+    if (Object.keys(ctx.utm).length > 0 || Object.keys(ctx.click_id).length > 0) {
+      const touch = {
+        utm: ctx.utm,
+        click_id: ctx.click_id,
+        referrer: document.referrer,
+        landing_url: window.location.href,
+        captured_at: Date.now()
+      };
+      preserveFirstSource(touch);
+    }
+    this.autocaptureHandle = startAutocapture(opts.autocapture, {
+      pageView: (url, title, referrer) => this.queueEvent("page_view", "interaction", { url, title, referrer }),
+      click: (payload) => {
+        const ev = payload.custom_event ?? "element_clicked";
+        const props = {
+          element_tag: payload.element_tag,
+          ...payload.element_id ? { element_id: payload.element_id } : {},
+          ...payload.element_class ? { element_class: payload.element_class } : {},
+          ...payload.element_text ? { element_text: payload.element_text } : {},
+          ...payload.href ? { href: payload.href } : {},
+          ...payload.is_outbound ? { is_outbound: true } : {},
+          ...payload.is_download ? { is_download: true } : {},
+          ...payload.custom_props ?? {}
+        };
+        this.queueEvent(ev, "interaction", props);
+      },
+      formStarted: (p) => this.queueEvent("form_started", "interaction", p),
+      formSubmitted: (p) => this.queueEvent("form_submitted", "interaction", p),
+      scrollDepth: (p) => this.queueEvent("scroll_depth", "interaction", p),
+      webVital: (p) => this.queueEvent("web_vital", "interaction", p),
+      jsError: (p) => this.queueEvent("js_error", "interaction", p)
+    });
+    this.initialized = true;
+  }
+  track(eventKey, properties) {
+    this.queueEvent(eventKey, "interaction", properties);
+  }
+  page(override) {
+    if (!this.initialized || typeof window === "undefined")
+      return;
+    const url = override?.url ?? window.location.href;
+    const title = override?.title ?? document.title;
+    const referrer = override?.referrer ?? document.referrer;
+    this.queueEvent("page_view", "interaction", { url, title, referrer });
+  }
+  async identify(personId, traits) {
+    if (!this.initialized || isOptedOut())
+      return;
+    setPersonId(personId);
+    if (!this.opts)
+      return;
+    try {
+      await sendIdentify({
+        endpoint: this.opts.endpoint ?? DEFAULT_ENDPOINT,
+        workspaceKey: this.opts.workspaceKey,
+        sdkVersion: SDK_VERSION
+      }, {
+        anonymous_id: this.anonymousId,
+        external_user_id: personId,
+        ...traits?.email ? { email: traits.email } : {},
+        ...traits?.phone ? { phone: traits.phone } : {},
+        ...traits ? { traits } : {}
+      });
+    } catch (err) {
+      if (this.opts?.debug && typeof console !== "undefined") {
+        console.warn("[gurulu] identify failed", err);
+      }
+    }
+  }
+  reset() {
+    this.anonymousId = clearIdentity();
+    if (typeof window !== "undefined") {
+      try {
+        window.localStorage.removeItem("gurulu_sid");
+        window.localStorage.removeItem("gurulu_session_started_at");
+        window.localStorage.removeItem("gurulu_last_event_at");
+        window.localStorage.removeItem("gurulu_first_source");
+      } catch {}
+    }
+    this.session = resolveSession();
+  }
+  async flush() {
+    await this.queue?.flush();
+  }
+  optOut() {
+    setOptOut(true);
+  }
+  optIn() {
+    setOptOut(false);
+  }
+  queueEvent(eventKey, eventType, properties) {
+    if (!this.initialized || !this.queue || isOptedOut())
+      return;
+    if (!this.consentAllowsAnalytics() && this.opts?.consent_mode === "banner_required") {
+      return;
+    }
+    this.session = resolveSession();
+    const event = {
+      anonymous_id: this.anonymousId ?? "anon_unknown",
+      event_id: newEventId(),
+      event_key: eventKey,
+      event_type: eventType,
+      occurred_at: nowIso(),
+      producer: "script",
+      producer_version: SDK_VERSION,
+      ...this.session ? { session_id: this.session.session_id } : {}
+    };
+    const pid = getPersonId();
+    if (pid)
+      event.person_id = pid;
+    if (properties && Object.keys(properties).length > 0)
+      event.properties = properties;
+    const ctx = this.buildContext();
+    if (ctx)
+      event.context = ctx;
+    const consent = this.snapshotConsent();
+    if (consent)
+      event.consent_state = consent;
+    if (this.testMode)
+      event.test_mode = true;
+    this.queue.enqueue(event);
+  }
+  snapshotConsent() {
+    const snap = this.consent?.getState();
+    if (!snap)
+      return;
+    return {
+      necessary: snap.categories.necessary,
+      analytics: snap.categories.analytics,
+      marketing: snap.categories.marketing,
+      functional: snap.categories.functional,
+      personalization: snap.categories.personalization
+    };
+  }
+  consentAllowsAnalytics() {
+    const snap = this.consent?.getState();
+    if (!snap)
+      return false;
+    return snap.categories.analytics === true;
+  }
+  buildContext() {
+    if (typeof window === "undefined")
+      return;
+    const ctx = {
+      url: window.location.href,
+      referrer: document.referrer,
+      page_title: document.title,
+      user_agent: navigator.userAgent,
+      domain: window.location.hostname
+    };
+    const first = getFirstSource();
+    if (first?.utm && Object.keys(first.utm).length > 0)
+      ctx.utm = first.utm;
+    if (first?.click_id && Object.keys(first.click_id).length > 0)
+      ctx.click_id = first.click_id;
+    return ctx;
+  }
+}
+// src/index.ts
+var VERSION = "0.1.0";
+var singleton = new Gurulu;
+function createGurulu() {
+  return new Gurulu;
+}
+var publicSdk = {
+  init: (opts) => singleton.init(opts),
+  track: (eventKey, properties) => singleton.track(eventKey, properties),
+  identify: (personId, traits) => singleton.identify(personId, traits),
+  page: (override) => singleton.page(override),
+  reset: () => singleton.reset(),
+  flush: () => singleton.flush(),
+  optOut: () => singleton.optOut(),
+  optIn: () => singleton.optIn(),
+  get consent() {
+    return singleton.consent;
+  },
+  get activation() {
+    return singleton.activation;
+  },
+  VERSION
+};
+function autoBootstrap() {
+  if (typeof document === "undefined")
+    return;
+  const script = document.currentScript;
+  const fallback = !script ? document.querySelector("script[data-workspace]") : script;
+  if (!fallback)
+    return;
+  const workspaceKey = fallback.getAttribute("data-workspace");
+  if (!workspaceKey)
+    return;
+  const opts = { workspaceKey };
+  const endpoint = fallback.getAttribute("data-endpoint");
+  if (endpoint)
+    opts.endpoint = endpoint;
+  const apiUrl = fallback.getAttribute("data-api-url");
+  if (apiUrl)
+    opts.apiUrl = apiUrl;
+  const consentMode = fallback.getAttribute("data-consent");
+  if (consentMode === "banner_required" || consentMode === "allow_by_default") {
+    opts.consent_mode = consentMode;
+  }
+  const allowlist = fallback.getAttribute("data-allowlist");
+  if (allowlist)
+    opts.cross_domain_allowlist = allowlist.split(",").map((s) => s.trim());
+  publicSdk.init(opts);
+  if (typeof window !== "undefined") {
+    window.gurulu = publicSdk;
+  }
+}
+autoBootstrap();
+var src_default = publicSdk;
+
+// src/react.ts
+import { useEffect } from "react";
+function GuruluProvider({ children, ...opts }) {
+  useEffect(() => {
+    src_default.init(opts);
+  }, []);
+  return children;
+}
+function useGurulu() {
+  return src_default;
+}
+export {
+  useGurulu,
+  GuruluProvider
+};