@glassanalytics/browser 0.1.0

package/dist/index.js

@@ -0,0 +1,1022 @@
+import { randomToken, prefixedId, evaluateFlag, INGEST_AUTH_SCHEME, replaySegmentPath } from '@glassanalytics/core';
+
+// src/index.ts
+
+// src/replay-encoder.ts
+var WORKER_SRC = `
+self.onmessage = async function (e) {
+  var id = e.data.id, json = e.data.json;
+  try {
+    var bytes = new TextEncoder().encode(json);
+    if (typeof CompressionStream !== 'undefined') {
+      var cs = new CompressionStream('gzip');
+      var w = cs.writable.getWriter();
+      w.write(bytes); w.close();
+      var buf = await new Response(cs.readable).arrayBuffer();
+      self.postMessage({ id: id, buf: buf, gzip: true }, [buf]);
+    } else {
+      self.postMessage({ id: id, buf: bytes.buffer, gzip: false }, [bytes.buffer]);
+    }
+  } catch (err) {
+    self.postMessage({ id: id, error: String(err) });
+  }
+};
+`;
+var ReplayEncoder = class {
+  worker = null;
+  workerUrl = null;
+  workerBroken = false;
+  nextId = 1;
+  pending = /* @__PURE__ */ new Map();
+  /** Lazily spin up the encode worker; null if Workers/Blob URLs aren't available. */
+  ensureWorker() {
+    if (this.worker || this.workerBroken) return this.worker;
+    try {
+      if (typeof Worker === "undefined" || typeof Blob === "undefined" || typeof URL === "undefined") {
+        this.workerBroken = true;
+        return null;
+      }
+      this.workerUrl = URL.createObjectURL(new Blob([WORKER_SRC], { type: "text/javascript" }));
+      this.worker = new Worker(this.workerUrl);
+      this.worker.onmessage = (ev) => {
+        const resolve = this.pending.get(ev.data.id);
+        if (resolve) {
+          this.pending.delete(ev.data.id);
+          resolve(ev.data);
+        }
+      };
+      this.worker.onerror = () => {
+        this.workerBroken = true;
+        for (const [, resolve] of this.pending) resolve({ id: -1, error: "worker_error" });
+        this.pending.clear();
+      };
+      return this.worker;
+    } catch {
+      this.workerBroken = true;
+      return null;
+    }
+  }
+  async encode(segment) {
+    let json;
+    try {
+      json = JSON.stringify(segment);
+    } catch {
+      json = "[]";
+    }
+    const worker = this.ensureWorker();
+    if (worker) {
+      try {
+        const reply = await this.postToWorker(worker, json);
+        if (!reply.error && reply.buf) {
+          return { body: new Uint8Array(reply.buf), gzip: reply.gzip === true };
+        }
+      } catch {
+      }
+    }
+    return this.encodeMainThread(json);
+  }
+  postToWorker(worker, json) {
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error("encode_timeout"));
+      }, 2e3);
+      this.pending.set(id, (r) => {
+        clearTimeout(timeout);
+        resolve(r);
+      });
+      worker.postMessage({ id, json });
+    });
+  }
+  /** Main-thread fallback: gzip via CompressionStream when present, else raw JSON. */
+  async encodeMainThread(json) {
+    const CS = globalThis.CompressionStream;
+    if (typeof CS !== "undefined") {
+      try {
+        const cs = new CS("gzip");
+        const writer = cs.writable.getWriter();
+        void writer.write(new TextEncoder().encode(json));
+        void writer.close();
+        const buf = await new Response(cs.readable).arrayBuffer();
+        return { body: new Uint8Array(buf), gzip: true };
+      } catch {
+      }
+    }
+    return { body: json, gzip: false };
+  }
+  dispose() {
+    this.worker?.terminate();
+    this.worker = null;
+    if (this.workerUrl) {
+      try {
+        URL.revokeObjectURL(this.workerUrl);
+      } catch {
+      }
+      this.workerUrl = null;
+    }
+    this.pending.clear();
+  }
+};
+
+// src/replay.ts
+var SENSITIVE_INPUT_TYPES = /* @__PURE__ */ new Set(["password", "email", "tel", "hidden"]);
+var SENSITIVE_NAME_RE = /pass|secret|token|ssn|card|cvv|cvc|account|email|phone|tax/i;
+var ReplayRecorder = class {
+  constructor(cfg, getSessionId) {
+    this.cfg = cfg;
+    this.getSessionId = getSessionId;
+  }
+  cfg;
+  getSessionId;
+  stop = null;
+  seq = 0;
+  events = [];
+  interval = null;
+  boundFinal = null;
+  encoder = new ReplayEncoder();
+  async start() {
+    if (this.stop) return;
+    if (typeof window === "undefined") return;
+    const { record } = await import('rrweb');
+    this.stop = record({
+      emit: (event) => {
+        this.events.push(event);
+        if (this.events.length >= 50) void this.flushSegment();
+      },
+      // Privacy defaults: never leak user input.
+      maskAllInputs: this.cfg.maskAllInputs,
+      maskTextSelector: this.cfg.maskTextSelector,
+      blockSelector: this.cfg.blockSelector,
+      // ALWAYS mask sensitive fields regardless of maskAllInputs (defense in depth).
+      maskInputFn: (text, element) => {
+        if (this.cfg.maskAllInputs) return "*".repeat(text.length);
+        const type = (element.getAttribute("type") ?? "").toLowerCase();
+        const name = `${element.getAttribute("name") ?? ""} ${element.getAttribute("autocomplete") ?? ""} ${element.id}`;
+        if (SENSITIVE_INPUT_TYPES.has(type) || SENSITIVE_NAME_RE.test(name)) return "*".repeat(text.length);
+        return text;
+      },
+      recordCanvas: false,
+      collectFonts: false
+    }) ?? null;
+    this.interval = setInterval(() => void this.flushSegment(), 5e3);
+    this.boundFinal = () => this.flushFinalBeacon();
+    window.addEventListener("pagehide", this.boundFinal);
+  }
+  async flushSegment() {
+    if (this.events.length === 0) return;
+    const segment = this.events.splice(0, this.events.length);
+    const seq = this.seq++;
+    const url = `${this.cfg.ingestHost}${replaySegmentPath(this.getSessionId(), seq)}`;
+    const encoded = await this.encoder.encode(segment);
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Glass-Key ${this.cfg.projectKey}`
+    };
+    if (encoded.gzip) headers["Content-Encoding"] = "gzip";
+    try {
+      await fetch(url, {
+        method: "POST",
+        keepalive: true,
+        headers,
+        body: encoded.body
+      });
+    } catch {
+    }
+  }
+  /** Flush the trailing segment with sendBeacon so it survives page teardown. */
+  flushFinalBeacon() {
+    if (this.events.length === 0) return;
+    const segment = this.events.splice(0, this.events.length);
+    const seq = this.seq++;
+    const url = `${this.cfg.ingestHost}${replaySegmentPath(this.getSessionId(), seq)}?k=${encodeURIComponent(this.cfg.projectKey)}`;
+    const payload = JSON.stringify(segment);
+    if (typeof navigator !== "undefined" && navigator.sendBeacon) {
+      navigator.sendBeacon(url, payload);
+    }
+  }
+  async stopRecording() {
+    await this.flushSegment();
+    this.stop?.();
+    this.stop = null;
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    if (this.boundFinal && typeof window !== "undefined") {
+      window.removeEventListener("pagehide", this.boundFinal);
+      this.boundFinal = null;
+    }
+    this.encoder.dispose();
+  }
+  get recording() {
+    return this.stop !== null;
+  }
+};
+
+// src/offline-store.ts
+var DB_NAME = "glass";
+var STORE = "offline_q";
+var LS_KEY = "glass_offline_q";
+var OfflineStore = class {
+  constructor(max, ttlMs) {
+    this.max = max;
+    this.ttlMs = ttlMs;
+  }
+  max;
+  ttlMs;
+  mem = [];
+  dbPromise = null;
+  idb() {
+    if (typeof indexedDB === "undefined") return null;
+    if (!this.dbPromise) {
+      this.dbPromise = new Promise((resolve, reject) => {
+        const req = indexedDB.open(DB_NAME, 1);
+        req.onupgradeneeded = () => {
+          const db = req.result;
+          if (!db.objectStoreNames.contains(STORE)) db.createObjectStore(STORE, { autoIncrement: true });
+        };
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+      }).catch((err) => {
+        this.dbPromise = null;
+        throw err;
+      });
+    }
+    return this.dbPromise;
+  }
+  fresh(items) {
+    const cutoff = Date.now() - this.ttlMs;
+    const kept = items.filter((b) => b.at >= cutoff);
+    return kept.length > this.max ? kept.slice(kept.length - this.max) : kept;
+  }
+  async append(batch) {
+    try {
+      const db = await this.idb();
+      if (db) {
+        await this.idbWrite(db, batch);
+        return;
+      }
+    } catch {
+    }
+    if (this.tryLS((q) => this.fresh([...q, batch]))) return;
+    this.mem = this.fresh([...this.mem, batch]);
+  }
+  async drain() {
+    try {
+      const db = await this.idb();
+      if (db) return this.fresh(await this.idbDrain(db));
+    } catch {
+    }
+    const ls2 = this.readLS();
+    if (ls2 !== null) {
+      this.writeLS([]);
+      return this.fresh(ls2);
+    }
+    const m = this.mem;
+    this.mem = [];
+    return this.fresh(m);
+  }
+  async clear() {
+    this.mem = [];
+    try {
+      const db = await this.idb();
+      if (db) {
+        await new Promise((resolve) => {
+          const tx = db.transaction(STORE, "readwrite");
+          tx.objectStore(STORE).clear();
+          tx.oncomplete = () => resolve();
+          tx.onerror = () => resolve();
+        });
+      }
+    } catch {
+    }
+    this.writeLS([]);
+  }
+  // --- IndexedDB helpers ------------------------------------------------------
+  idbWrite(db, batch) {
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE, "readwrite");
+      tx.objectStore(STORE).add(batch);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  idbDrain(db) {
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE, "readwrite");
+      const store = tx.objectStore(STORE);
+      const getAll = store.getAll();
+      getAll.onsuccess = () => {
+        store.clear();
+        resolve(getAll.result ?? []);
+      };
+      getAll.onerror = () => reject(getAll.error);
+    });
+  }
+  // --- localStorage fallback --------------------------------------------------
+  readLS() {
+    if (typeof localStorage === "undefined") return null;
+    try {
+      const raw = localStorage.getItem(LS_KEY);
+      return raw ? JSON.parse(raw) : [];
+    } catch {
+      return null;
+    }
+  }
+  writeLS(q) {
+    if (typeof localStorage === "undefined") return;
+    try {
+      localStorage.setItem(LS_KEY, JSON.stringify(q));
+    } catch {
+    }
+  }
+  tryLS(update) {
+    const cur = this.readLS();
+    if (cur === null) return false;
+    this.writeLS(update(cur));
+    return true;
+  }
+};
+
+// src/transport.ts
+var QUEUE_TTL_MS = 24 * 36e5;
+var QUEUE_MAX = 500;
+var BUFFER_MAX = 1e3;
+var BACKOFF_BASE_MS = 1e3;
+var BACKOFF_CAP_MS = 5 * 6e4;
+function eventValue(e) {
+  switch (e.type) {
+    case "error":
+      return 100;
+    case "identify":
+    case "group":
+      return 90;
+    case "exposure":
+      return 80;
+    case "track":
+      return e.event === "$autocapture" || e.event === "$pageview" ? 10 : 50;
+    default:
+      return 40;
+  }
+}
+var Transport = class {
+  constructor(cfg, getIdentity) {
+    this.cfg = cfg;
+    this.getIdentity = getIdentity;
+    if (typeof window !== "undefined") {
+      window.addEventListener("pagehide", this.onPageHide);
+      window.addEventListener("online", this.onOnline);
+    }
+  }
+  cfg;
+  getIdentity;
+  buffer = [];
+  timer = null;
+  retryTimer = null;
+  backoffUntil = 0;
+  failures = 0;
+  store = new OfflineStore(QUEUE_MAX, QUEUE_TTL_MS);
+  onPageHide = () => void this.flush(true);
+  onOnline = () => void this.drainOffline();
+  /** Remove window listeners and pending timers (called from Glass.shutdown()). */
+  destroy() {
+    if (typeof window !== "undefined") {
+      window.removeEventListener("pagehide", this.onPageHide);
+      window.removeEventListener("online", this.onOnline);
+    }
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.retryTimer) {
+      clearTimeout(this.retryTimer);
+      this.retryTimer = null;
+    }
+  }
+  enqueue(event) {
+    const finalEvent = this.cfg.beforeSend(event);
+    if (!finalEvent) return;
+    this.buffer.push(finalEvent);
+    this.applyBackpressure();
+    if (this.buffer.length >= this.cfg.flushAt) {
+      void this.flush();
+    } else if (!this.timer) {
+      this.timer = setTimeout(() => void this.flush(), this.cfg.flushIntervalMs);
+    }
+  }
+  /**
+   * Cap the in-memory buffer by shedding the lowest-value events when it grows
+   * past BUFFER_MAX (e.g. a long offline burst of autocapture). Errors and
+   * identity events are kept preferentially.
+   */
+  applyBackpressure() {
+    if (this.buffer.length <= BUFFER_MAX) return;
+    const indexed = this.buffer.map((e, i) => ({ e, i }));
+    indexed.sort((a, b) => eventValue(b.e) - eventValue(a.e) || a.i - b.i);
+    const kept = indexed.slice(0, BUFFER_MAX).sort((a, b) => a.i - b.i);
+    this.buffer = kept.map((x) => x.e);
+  }
+  async flush(useBeacon = false) {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    if (this.buffer.length === 0) return;
+    const events = this.buffer.splice(0, this.buffer.length);
+    const body = {
+      sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+      ...this.getIdentity(),
+      events
+    };
+    if (Date.now() < this.backoffUntil) {
+      await this.store.append({ at: Date.now(), body });
+      this.scheduleRetry();
+      return;
+    }
+    await this.send(body, useBeacon);
+  }
+  async send(body, useBeacon) {
+    const url = `${this.cfg.ingestHost}/v1/batch`;
+    const payload = JSON.stringify(body);
+    if (useBeacon && typeof navigator !== "undefined" && navigator.sendBeacon) {
+      navigator.sendBeacon(`${url}?k=${encodeURIComponent(this.cfg.projectKey)}`, payload);
+      return;
+    }
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        keepalive: true,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `${INGEST_AUTH_SCHEME} ${this.cfg.projectKey}`
+        },
+        body: payload
+      });
+      if (res.status === 429) {
+        const retry = Number(res.headers.get("retry-after") ?? "0");
+        this.failures++;
+        this.backoffUntil = Date.now() + (retry > 0 ? retry * 1e3 : this.backoffMs());
+        await this.store.append({ at: Date.now(), body });
+        this.scheduleRetry();
+      } else if (res.status >= 500) {
+        this.failures++;
+        this.backoffUntil = Date.now() + this.backoffMs();
+        await this.store.append({ at: Date.now(), body });
+        this.scheduleRetry();
+      } else {
+        this.failures = 0;
+      }
+    } catch {
+      this.failures++;
+      this.backoffUntil = Date.now() + this.backoffMs();
+      await this.store.append({ at: Date.now(), body });
+      this.scheduleRetry();
+    }
+  }
+  /** Exponential backoff with full jitter, capped. */
+  backoffMs() {
+    const exp = Math.min(BACKOFF_CAP_MS, BACKOFF_BASE_MS * 2 ** Math.min(this.failures, 12));
+    return Math.floor(Math.random() * exp);
+  }
+  scheduleRetry() {
+    if (this.retryTimer) return;
+    const delay = Math.max(0, this.backoffUntil - Date.now()) + 250;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      void this.drainOffline();
+    }, delay);
+  }
+  // --- durable offline queue (masked data only; TTL'd; size-capped) ----------
+  async drainOffline() {
+    if (Date.now() < this.backoffUntil) {
+      this.scheduleRetry();
+      return;
+    }
+    const q = await this.store.drain();
+    for (const item of q) {
+      if (Date.now() < this.backoffUntil) {
+        await this.store.append(item);
+        this.scheduleRetry();
+        return;
+      }
+      await this.send(item.body, false);
+    }
+  }
+  /** optOut/reset clears any queued (but already-masked) payloads. */
+  clearOffline() {
+    void this.store.clear();
+  }
+  /** Drop the in-memory buffer so no buffered PII survives optOut()/reset(). */
+  clearBuffer() {
+    this.buffer = [];
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+};
+
+// src/index.ts
+var SESSION_IDLE_MS = 30 * 6e4;
+var DEVICE_KEY = "glass_device_id";
+var SESSION_KEY = "glass_session";
+function ls() {
+  try {
+    return typeof localStorage !== "undefined" ? localStorage : null;
+  } catch {
+    return null;
+  }
+}
+var Glass = class {
+  cfg;
+  transport;
+  replay;
+  deviceId = "";
+  sessionId = "";
+  userId = null;
+  traits = {};
+  groupCtx = null;
+  superProps = {};
+  seq = 0;
+  lastActivity = 0;
+  flags = {};
+  flagsLoaded = false;
+  flagListeners = [];
+  optedOut = false;
+  started = false;
+  /** Calls made before init() are queued and replayed once started (`SDK.md` §2). */
+  preInitQueue = [];
+  /** Removers for every listener/patch we install, so shutdown() leaves no trace. */
+  teardowns = [];
+  init(config) {
+    if (this.started) return;
+    this.cfg = {
+      projectKey: config.projectKey,
+      ingestHost: config.ingestHost ?? "https://in.glass.dev",
+      apiHost: config.apiHost ?? "https://api.glass.dev",
+      replay: config.replay ?? true,
+      autocapture: config.autocapture ?? true,
+      errors: config.errors ?? true,
+      captureConsole: config.captureConsole ?? false,
+      sampleRate: config.sampleRate ?? 1,
+      consent: config.consent ?? "implied",
+      maskAllInputs: config.maskAllInputs ?? true,
+      maskTextSelector: config.maskTextSelector,
+      blockSelector: config.blockSelector,
+      respectDoNotTrack: config.respectDoNotTrack ?? true,
+      flushIntervalMs: config.flushIntervalMs ?? 5e3,
+      flushAt: config.flushAt ?? 25,
+      beforeSend: config.beforeSend ?? ((e) => e),
+      bootstrapFlags: config.bootstrapFlags ?? {},
+      flagDefinitions: config.flagDefinitions ?? []
+    };
+    this.flags = { ...this.cfg.bootstrapFlags };
+    if (this.cfg.respectDoNotTrack && typeof navigator !== "undefined" && navigator.doNotTrack === "1") {
+      this.optedOut = true;
+    }
+    this.deviceId = this.loadDeviceId();
+    this.sessionId = this.loadSession();
+    this.transport = new Transport(this.cfg, () => ({
+      device_id: this.deviceId,
+      session_id: this.sessionId,
+      ...this.userId ? { user_id: this.userId } : {},
+      traits: this.traits,
+      ...this.groupCtx ? { group: this.groupCtx } : {}
+    }));
+    this.replay = new ReplayRecorder(this.cfg, () => this.sessionId);
+    this.started = true;
+    if (this.optedOut || this.cfg.consent === "opt-in") ; else {
+      this.afterConsent();
+    }
+    void this.reloadFeatureFlags();
+    const queued = this.preInitQueue.splice(0, this.preInitQueue.length);
+    for (const fn of queued) fn();
+  }
+  afterConsent() {
+    if (this.cfg.errors) this.installErrorHandlers();
+    if (this.cfg.autocapture) this.installAutocapture();
+    if (this.cfg.captureConsole) this.installConsoleCapture();
+    this.installVisibilityFlush();
+    if (this.cfg.replay && Math.random() < this.cfg.sampleRate) void this.replay.start();
+    void this.transport.drainOffline();
+    this.track("$pageview", this.pageProps());
+  }
+  /** Register a DOM listener and remember how to remove it on shutdown(). */
+  addListener(target, type, handler, opts) {
+    target.addEventListener(type, handler, opts);
+    this.teardowns.push(() => target.removeEventListener(type, handler, opts));
+  }
+  /**
+   * Flush on tab hide (`SDK.md` §10). `visibilitychange`→hidden is the most
+   * reliable "user is leaving" signal on mobile (where `pagehide`/`unload` are
+   * unreliable), so we drain the buffer with a beacon while we still can.
+   */
+  installVisibilityFlush() {
+    if (typeof document === "undefined") return;
+    this.addListener(document, "visibilitychange", () => {
+      if (document.visibilityState === "hidden") void this.transport.flush(true);
+    });
+  }
+  // --- identity --------------------------------------------------------------
+  loadDeviceId() {
+    const store = ls();
+    let id = store?.getItem(DEVICE_KEY) ?? null;
+    if (!id) {
+      id = `dev_${randomToken(16)}`;
+      store?.setItem(DEVICE_KEY, id);
+    }
+    return id;
+  }
+  loadSession() {
+    const store = ls();
+    try {
+      const raw = store?.getItem(SESSION_KEY);
+      if (raw) {
+        const parsed = JSON.parse(raw);
+        if (Date.now() - parsed.last < SESSION_IDLE_MS) {
+          this.lastActivity = parsed.last;
+          return parsed.id;
+        }
+      }
+    } catch {
+    }
+    const id = prefixedId("sess");
+    this.persistSession(id);
+    return id;
+  }
+  persistSession(id) {
+    this.lastActivity = Date.now();
+    ls()?.setItem(SESSION_KEY, JSON.stringify({ id, last: this.lastActivity }));
+  }
+  touchSession() {
+    if (Date.now() - this.lastActivity > SESSION_IDLE_MS) {
+      this.sessionId = prefixedId("sess");
+      this.seq = 0;
+    }
+    this.persistSession(this.sessionId);
+  }
+  /** Queue a call made before init() so nothing is lost; returns true if deferred. */
+  deferred(fn) {
+    if (this.started) return false;
+    this.preInitQueue.push(fn);
+    return true;
+  }
+  identify(userId, traits = {}) {
+    if (this.deferred(() => this.identify(userId, traits))) return;
+    this.userId = userId;
+    this.traits = { ...this.traits, ...traits };
+    this.emit("identify", void 0, traits);
+    void this.reloadFeatureFlags();
+  }
+  reset() {
+    void this.transport.flush();
+    this.transport.clearBuffer();
+    this.transport.clearOffline();
+    this.exposedKeys.clear();
+    this.flags = { ...this.cfg.bootstrapFlags };
+    this.userId = null;
+    this.traits = {};
+    this.groupCtx = null;
+    this.superProps = {};
+    const store = ls();
+    store?.removeItem(SESSION_KEY);
+    this.deviceId = `dev_${randomToken(16)}`;
+    store?.setItem(DEVICE_KEY, this.deviceId);
+    this.sessionId = prefixedId("sess");
+    this.seq = 0;
+  }
+  getDeviceId() {
+    return this.deviceId;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getSessionReplayUrl() {
+    return `${this.cfg.apiHost}/replays/${this.sessionId}`;
+  }
+  groupIdentify(type, key, traits = {}) {
+    if (this.deferred(() => this.groupIdentify(type, key, traits))) return;
+    this.groupCtx = { type, key };
+    this.emit("group", void 0, { group_type: type, group_key: key, ...traits });
+  }
+  /** Alias for `groupIdentify` (`SDK.md` API parity). */
+  group(type, key, traits = {}) {
+    this.groupIdentify(type, key, traits);
+  }
+  // --- events ----------------------------------------------------------------
+  register(props) {
+    if (this.deferred(() => this.register(props))) return;
+    this.superProps = { ...this.superProps, ...props };
+  }
+  unregister(key) {
+    if (this.deferred(() => this.unregister(key))) return;
+    delete this.superProps[key];
+  }
+  track(event, props = {}) {
+    if (this.deferred(() => this.track(event, props))) return;
+    this.emit("track", event, props);
+  }
+  emit(type, event, props) {
+    if (this.optedOut || !this.started) return;
+    this.touchSession();
+    this.transport.enqueue({
+      type,
+      ...event ? { event } : {},
+      seq: this.seq++,
+      t_client: (/* @__PURE__ */ new Date()).toISOString(),
+      props: { ...this.contextProps(), ...this.superProps, ...props }
+    });
+  }
+  /** Device/screen context attached to EVERY event (`SDK.md` §4). */
+  contextProps() {
+    const ctx = {};
+    if (typeof screen !== "undefined") {
+      ctx.$screen_width = screen.width;
+      ctx.$screen_height = screen.height;
+    }
+    if (typeof window !== "undefined") {
+      ctx.$viewport_width = window.innerWidth;
+      ctx.$viewport_height = window.innerHeight;
+    }
+    if (typeof navigator !== "undefined") {
+      ctx.$locale = navigator.language ?? null;
+    }
+    return ctx;
+  }
+  pageProps() {
+    if (typeof document === "undefined" || typeof location === "undefined") return {};
+    return { url: location.href, $pathname: location.pathname, referrer: document.referrer };
+  }
+  // --- errors ----------------------------------------------------------------
+  captureException(error, context = {}) {
+    if (this.deferred(() => this.captureException(error, context))) return;
+    const err = error instanceof Error ? error : new Error(String(error));
+    this.emit("error", err.name, {
+      message: err.message,
+      stack: err.stack ?? "",
+      ...context
+    });
+  }
+  /** Breadcrumb with optional category (`SDK.md` API parity). */
+  addBreadcrumb(arg, data = {}) {
+    if (this.deferred(() => this.addBreadcrumb(arg, data))) return;
+    if (typeof arg === "string") {
+      this.emit("track", "$breadcrumb", { message: arg, ...data });
+    } else {
+      this.emit("track", "$breadcrumb", {
+        message: arg.message,
+        ...arg.category ? { category: arg.category } : {},
+        ...arg.data ?? {}
+      });
+    }
+  }
+  installErrorHandlers() {
+    if (typeof window === "undefined") return;
+    this.addListener(
+      window,
+      "error",
+      (e) => this.captureException(e.error ?? e.message)
+    );
+    this.addListener(
+      window,
+      "unhandledrejection",
+      (e) => this.captureException(e.reason)
+    );
+  }
+  /**
+   * Opt-in console capture (`SDK.md` §5): mirror `console.error`/`console.warn`
+   * into Glass (errors as exceptions, warnings as breadcrumbs) while ALWAYS
+   * calling through to the original console, so we never swallow the developer's
+   * own logs. Restored verbatim on shutdown().
+   */
+  installConsoleCapture() {
+    if (typeof console === "undefined") return;
+    const wrap = (level) => {
+      const original = console[level];
+      if (typeof original !== "function") return;
+      console[level] = (...args) => {
+        try {
+          const first = args[0];
+          const message = args.map((a) => typeof a === "string" ? a : a instanceof Error ? a.message : safeString(a)).join(" ").slice(0, 500);
+          if (level === "error") {
+            this.captureException(first instanceof Error ? first : new Error(message), { $console: true });
+          } else {
+            this.addBreadcrumb({ category: "console.warn", message });
+          }
+        } catch {
+        }
+        return original.apply(console, args);
+      };
+      this.teardowns.push(() => {
+        console[level] = original;
+      });
+    };
+    wrap("error");
+    wrap("warn");
+  }
+  rageWindow = [];
+  installAutocapture() {
+    if (typeof document === "undefined") return;
+    this.addListener(
+      document,
+      "click",
+      (e) => {
+        const target = e.target;
+        if (!target) return;
+        this.detectRageClick();
+        const el = target.closest("a,button,input[type=submit],[role=button],[data-glass]");
+        if (!el) return;
+        this.track("$click", this.elementProps(el));
+      },
+      { capture: true }
+    );
+    this.addListener(
+      document,
+      "submit",
+      (e) => {
+        const form = e.target;
+        if (!form || form.tagName !== "FORM") return;
+        this.track("$form_submit", {
+          form_id: form.id || null,
+          form_name: form.getAttribute("name"),
+          action: form.getAttribute("action"),
+          field_count: form.elements.length
+        });
+      },
+      { capture: true }
+    );
+    this.installSpaPageviews();
+  }
+  /** Stable, value-free descriptor of a clicked element. */
+  elementProps(el) {
+    return {
+      tag: el.tagName.toLowerCase(),
+      text: (el.textContent ?? "").trim().slice(0, 80),
+      href: el instanceof HTMLAnchorElement ? el.href : null,
+      el_id: el.id || null,
+      el_class: el.getAttribute("class"),
+      data_glass: el.getAttribute("data-glass")
+    };
+  }
+  /** Three+ clicks within 1s at roughly one spot = a rage click (frustration signal). */
+  detectRageClick() {
+    const now = Date.now();
+    this.rageWindow = this.rageWindow.filter((t) => now - t < 1e3);
+    this.rageWindow.push(now);
+    if (this.rageWindow.length >= 3) {
+      this.rageWindow = [];
+      this.track("$rageclick", { url: typeof location !== "undefined" ? location.href : null });
+    }
+  }
+  /** SPA route changes: patch History + listen to popstate, de-duping same-URL. */
+  lastPath = "";
+  installSpaPageviews() {
+    if (typeof history === "undefined" || typeof location === "undefined") return;
+    this.lastPath = location.href;
+    const fire = () => {
+      if (location.href === this.lastPath) return;
+      this.lastPath = location.href;
+      this.track("$pageview", this.pageProps());
+    };
+    const wrap = (key) => {
+      const orig = history[key];
+      history[key] = function patched(...args) {
+        const ret = orig.apply(this, args);
+        setTimeout(fire, 0);
+        return ret;
+      };
+      this.teardowns.push(() => {
+        history[key] = orig;
+      });
+    };
+    wrap("pushState");
+    wrap("replaceState");
+    this.addListener(window, "popstate", fire);
+  }
+  // --- session replay control ------------------------------------------------
+  startSessionRecording() {
+    void this.replay.start();
+  }
+  stopSessionRecording() {
+    void this.replay.stopRecording();
+  }
+  // --- feature flags (deterministic, edge-evaluated) -------------------------
+  async reloadFeatureFlags() {
+    try {
+      const unit = this.userId ?? this.deviceId;
+      const res = await fetch(`${this.cfg.apiHost}/v1/sdk/flags?user_id=${encodeURIComponent(unit)}`, {
+        headers: { Authorization: `Glass-Key ${this.cfg.projectKey}` }
+      });
+      if (res.ok) {
+        const json = await res.json();
+        this.flags = { ...this.flags, ...json.flags ?? {} };
+      }
+    } catch {
+    } finally {
+      this.flagsLoaded = true;
+      for (const fn of this.flagListeners) fn(this.flags);
+    }
+  }
+  onFlagsLoaded(fn) {
+    this.flagListeners.push(fn);
+    if (this.flagsLoaded) fn(this.flags);
+  }
+  /**
+   * Resolve a flag value with precedence: locally-evaluated definition (if the
+   * app shipped one, so targeting reflects CURRENT properties) → server/bootstrap
+   * resolved value → fallback.
+   */
+  resolve(key, opts) {
+    const local = this.evaluateLocal(key);
+    const v = local !== void 0 ? local : this.flags[key];
+    const value = v !== void 0 ? v : opts?.fallback;
+    if (value !== void 0 && opts?.trackExposure !== false) this.exposure(key, value);
+    return value;
+  }
+  /** Local bucketing via @glassanalytics/core when definitions were provided to init(). */
+  evaluateLocal(key) {
+    const def = this.cfg.flagDefinitions.find((d) => d.key === key);
+    if (!def) return void 0;
+    const properties = {};
+    for (const [k, val] of Object.entries(this.traits)) {
+      if (val === null || typeof val === "string" || typeof val === "number" || typeof val === "boolean") {
+        properties[k] = val;
+      }
+    }
+    return evaluateFlag(def, { unitId: this.userId ?? this.deviceId, properties });
+  }
+  isFeatureEnabledSync(key, opts) {
+    const v = this.resolve(key, opts);
+    return v === true || typeof v === "string" && v !== "";
+  }
+  async isFeatureEnabled(key, opts) {
+    if (!this.flagsLoaded) await this.reloadFeatureFlags();
+    return this.isFeatureEnabledSync(key, opts);
+  }
+  getFeatureFlagSync(key, opts) {
+    return this.resolve(key, opts);
+  }
+  async getFeatureFlag(key, opts) {
+    if (!this.flagsLoaded) await this.reloadFeatureFlags();
+    return this.getFeatureFlagSync(key, opts);
+  }
+  getVariantSync(key, opts) {
+    return this.resolve(key, opts);
+  }
+  async getVariant(key, opts) {
+    if (!this.flagsLoaded) await this.reloadFeatureFlags();
+    return this.getVariantSync(key, opts);
+  }
+  /** Fire a `$exposure` once per (flag, value) so experiment analysis is honest (§8). */
+  exposedKeys = /* @__PURE__ */ new Set();
+  exposure(key, value) {
+    const k = `${key}=${String(value)}`;
+    if (this.exposedKeys.has(k)) return;
+    this.exposedKeys.add(k);
+    this.emit("exposure", key, { $feature_flag: key, $feature_flag_value: String(value) });
+  }
+  // --- consent ---------------------------------------------------------------
+  optIn() {
+    this.optedOut = false;
+    this.afterConsent();
+  }
+  optOut() {
+    this.optedOut = true;
+    this.transport.clearBuffer();
+    this.transport.clearOffline();
+    void this.replay.stopRecording();
+  }
+  hasConsent() {
+    return !this.optedOut;
+  }
+  // --- lifecycle -------------------------------------------------------------
+  flush() {
+    return this.transport.flush();
+  }
+  shutdown() {
+    void this.transport.flush(true);
+    void this.replay.stopRecording();
+    for (const off of this.teardowns.splice(0, this.teardowns.length).reverse()) {
+      try {
+        off();
+      } catch {
+      }
+    }
+    this.transport.destroy();
+    this.started = false;
+  }
+};
+function safeString(value) {
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+var glass = new Glass();
+var index_default = glass;
+
+export { Glass, index_default as default, glass };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map