@bugban/js 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1700 @@
+'use strict';
+
+// src/env.ts
+var SDK_NAME = "bugban-js";
+var SDK_VERSION = "1.0.0";
+var isBrowser = (() => {
+  try {
+    return typeof window !== "undefined" && typeof window.document !== "undefined";
+  } catch (e) {
+    return false;
+  }
+})();
+var isNode = (() => {
+  try {
+    return typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+  } catch (e) {
+    return false;
+  }
+})();
+function runtimeName() {
+  if (isBrowser) return "browser";
+  if (isNode) return "node";
+  return "unknown";
+}
+function runtimeVersion() {
+  try {
+    if (isNode) return process.versions.node;
+    if (isBrowser) return navigator.userAgent;
+  } catch (e) {
+  }
+  return void 0;
+}
+async function nodeModule2(name) {
+  if (!isNode) return void 0;
+  const prefixed = "node:".concat(name);
+  for (const spec of [prefixed, String(name)]) {
+    try {
+      const ns = await import(
+        /* @vite-ignore */
+        /* webpackIgnore: true */
+        spec
+      );
+      if (ns) return ns.default && !ns.hostname && !ns.existsSync ? ns.default : ns;
+    } catch (e) {
+    }
+  }
+  return tryRequire(name);
+}
+async function hostname() {
+  try {
+    if (isBrowser) return window.location.hostname;
+    if (isNode) {
+      const os = await nodeModule2("os");
+      if (os && typeof os.hostname === "function") return String(os.hostname());
+    }
+  } catch (e) {
+  }
+  return void 0;
+}
+async function appPackageInfo() {
+  if (!isNode) return {};
+  try {
+    const fs = await nodeModule2("fs");
+    const path = await nodeModule2("path");
+    if (!fs || !path || typeof fs.existsSync !== "function") return {};
+    let dir = process.cwd();
+    for (let depth = 0; depth < 6; depth++) {
+      const file = path.join(dir, "package.json");
+      if (fs.existsSync(file)) {
+        const json = JSON.parse(fs.readFileSync(file, "utf8"));
+        return { name: json.name, version: json.version };
+      }
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch (e) {
+  }
+  return {};
+}
+async function dependencyVersion(pkg) {
+  if (!isNode) return void 0;
+  try {
+    const mod = await nodeModule2("module");
+    if (mod && typeof mod.createRequire === "function") {
+      const r = mod.createRequire(process.cwd() + "/package.json");
+      const json = r(`${pkg}/package.json`);
+      return json && json.version ? String(json.version) : void 0;
+    }
+  } catch (e) {
+  }
+  return void 0;
+}
+function env(key) {
+  try {
+    if (typeof process !== "undefined" && process.env) {
+      const v = process.env[key];
+      return v == null || v === "" ? void 0 : String(v);
+    }
+  } catch (e) {
+  }
+  return void 0;
+}
+function tryRequire(name) {
+  try {
+    const req = typeof module !== "undefined" && typeof module.require === "function" ? module.require : typeof globalThis.require === "function" ? globalThis.require : void 0;
+    return req ? req(name) : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function deviceInfo() {
+  var _a, _b;
+  const out = {
+    sdk: SDK_NAME,
+    sdk_version: SDK_VERSION,
+    runtime: runtimeName(),
+    runtime_version: runtimeVersion()
+  };
+  try {
+    if (isBrowser) {
+      out.user_agent = navigator.userAgent;
+      out.language = navigator.language;
+      out.screen = { width: (_a = window.screen) == null ? void 0 : _a.width, height: (_b = window.screen) == null ? void 0 : _b.height };
+      out.viewport = { width: window.innerWidth, height: window.innerHeight };
+      out.online = navigator.onLine;
+    }
+    if (isNode) {
+      out.platform = process.platform;
+      out.arch = process.arch;
+      out.pid = process.pid;
+    }
+  } catch (e) {
+  }
+  return out;
+}
+
+// src/config.ts
+function section(value, defaults, defaultOn) {
+  if (value === false) return false;
+  if (value === true || value === void 0) return defaultOn || value === true ? defaults : false;
+  return { ...defaults, ...value };
+}
+var CONSOLE_DEFAULTS = {
+  levels: ["log", "info", "warn", "error", "debug"],
+  // Only console.error becomes an event. console.warn is far too noisy in a
+  // typical app — React alone emits several per render in development.
+  captureAsEvent: ["error"]
+};
+var NETWORK_DEFAULTS = {
+  enabled: true,
+  captureFailures: true,
+  ignoreUrls: []
+};
+var SNAPSHOT_DEFAULTS = {
+  enabled: true,
+  // Never flipped to false by a preset. Turning this off ships whatever the
+  // end user typed — passwords included — to the Bugban server, so it has to
+  // be an explicit, deliberate line in the app's own config.
+  maskInputs: true,
+  maskSelectors: [],
+  maxBytes: 5e5
+};
+var VITALS_DEFAULTS = {
+  enabled: true,
+  // Vitals describe the whole audience, not one error, so a sample is enough
+  // and keeps ingest volume proportional to traffic.
+  sampleRate: 0.2,
+  longTaskMs: 100,
+  slowResourceMs: 1e3
+};
+function resolveOptions(input = {}) {
+  var _a, _b;
+  const apiKey = input.apiKey || env("BUGBAN_API_KEY") || env("NEXT_PUBLIC_BUGBAN_API_KEY") || "";
+  const host = input.host || env("BUGBAN_HOST") || env("NEXT_PUBLIC_BUGBAN_HOST") || "https://bugban.online";
+  return {
+    ...input,
+    apiKey,
+    host: host.replace(/\/+$/, ""),
+    release: input.release || env("BUGBAN_RELEASE"),
+    environment: input.environment || env("BUGBAN_ENV") || env("NODE_ENV") || "production",
+    // No key means no-op, exactly like the PHP SDK: an app that ships
+    // without configuration must not error, it must simply do nothing.
+    enabled: input.enabled !== false && apiKey !== "",
+    debug: input.debug === true,
+    maxBreadcrumbs: clamp((_a = input.maxBreadcrumbs) != null ? _a : 50, 1, 200),
+    sampleRate: clamp((_b = input.sampleRate) != null ? _b : 1, 0, 1),
+    console: section(input.console, CONSOLE_DEFAULTS, true),
+    network: section(input.network, NETWORK_DEFAULTS, true),
+    snapshot: section(input.snapshot, SNAPSHOT_DEFAULTS, true),
+    vitals: section(input.vitals, VITALS_DEFAULTS, true),
+    globalHandlers: input.globalHandlers !== false,
+    domBreadcrumbs: input.domBreadcrumbs !== false,
+    installPing: input.installPing !== false,
+    redactKeys: input.redactKeys || [],
+    ignoreErrors: input.ignoreErrors || []
+  };
+}
+function clamp(n, min, max) {
+  if (typeof n !== "number" || isNaN(n)) return min;
+  return Math.min(max, Math.max(min, n));
+}
+
+// src/utils.ts
+function safe(fn, fallback) {
+  try {
+    return fn();
+  } catch (e) {
+    return fallback;
+  }
+}
+function nowIso() {
+  try {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  } catch (e) {
+    return "";
+  }
+}
+function truncate(value, max) {
+  const s = typeof value === "string" ? value : stringify(value);
+  return s.length > max ? s.slice(0, max) + "\u2026" : s;
+}
+function stringify(value, max = 2e3) {
+  try {
+    const seen = /* @__PURE__ */ new WeakSet();
+    const out = JSON.stringify(value, (_k, v) => {
+      if (typeof v === "bigint") return v.toString();
+      if (typeof v === "function") return "[Function]";
+      if (v instanceof Error) return { name: v.name, message: v.message };
+      if (typeof v === "object" && v !== null) {
+        if (seen.has(v)) return "[Circular]";
+        seen.add(v);
+      }
+      return v;
+    });
+    if (out == null) return String(value);
+    return out.length > max ? out.slice(0, max) + "\u2026" : out;
+  } catch (e) {
+    try {
+      return String(value);
+    } catch (e2) {
+      return "[unserializable]";
+    }
+  }
+}
+function matchesAny(value, patterns) {
+  for (const p of patterns) {
+    try {
+      if (typeof p === "string") {
+        if (value.indexOf(p) !== -1) return true;
+      } else if (p.test(value)) {
+        return true;
+      }
+    } catch (e) {
+    }
+  }
+  return false;
+}
+function randomId() {
+  try {
+    const c = globalThis.crypto;
+    if (c && typeof c.randomUUID === "function") return c.randomUUID();
+    if (c && typeof c.getRandomValues === "function") {
+      const b = new Uint8Array(16);
+      c.getRandomValues(b);
+      return Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
+    }
+  } catch (e) {
+  }
+  return Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+function sampled(rate2) {
+  if (rate2 >= 1) return true;
+  if (rate2 <= 0) return false;
+  return Math.random() < rate2;
+}
+function selectorFor(el) {
+  try {
+    const node = el;
+    if (!node || typeof node.tagName !== "string") return void 0;
+    let s = node.tagName.toLowerCase();
+    if (node.id) return `${s}#${node.id}`;
+    if (typeof node.className === "string" && node.className.trim()) {
+      const cls = node.className.trim().split(/\s+/).slice(0, 2).join(".");
+      if (cls) s += `.${cls}`;
+    }
+    return s;
+  } catch (e) {
+    return void 0;
+  }
+}
+
+// src/transport.ts
+function byteLength(s) {
+  try {
+    if (typeof TextEncoder === "function") return new TextEncoder().encode(s).length;
+  } catch (e) {
+  }
+  try {
+    const B = globalThis.Buffer;
+    if (B && typeof B.byteLength === "function") return B.byteLength(s);
+  } catch (e) {
+  }
+  let n = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 128) n += 1;
+    else if (c < 2048) n += 2;
+    else if (c >= 55296 && c <= 56319) {
+      n += 4;
+      i++;
+    } else n += 3;
+  }
+  return n;
+}
+var Transport = class {
+  constructor(host, apiKey, debug = false) {
+    this.host = host;
+    this.apiKey = apiKey;
+    this.debug = debug;
+  }
+  /** Fire-and-forget POST. Resolves to true when the server accepted it. */
+  async send(path, body, opts = {}) {
+    const url = this.host.replace(/\/+$/, "") + path;
+    let json;
+    try {
+      json = JSON.stringify(body);
+    } catch (e) {
+      return false;
+    }
+    if (opts.beacon && isBrowser) {
+      const sent = safe(() => {
+        const nav = navigator;
+        if (typeof nav.sendBeacon !== "function") return false;
+        const blob = new Blob([JSON.stringify({ ...body, _key: this.apiKey })], {
+          type: "application/json"
+        });
+        return nav.sendBeacon(url, blob);
+      }, false);
+      if (sent) return true;
+    }
+    if (typeof fetch === "function") {
+      return this.viaFetch(url, json, opts);
+    }
+    if (isNode) {
+      return this.viaNodeHttp(url, json, opts);
+    }
+    this.log("no transport available");
+    return false;
+  }
+  async viaFetch(url, json, opts) {
+    var _a;
+    try {
+      const controller = typeof AbortController === "function" ? new AbortController() : void 0;
+      const timer = controller ? setTimeout(() => safe(() => controller.abort()), (_a = opts.timeoutMs) != null ? _a : 8e3) : void 0;
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Bugban-Key": this.apiKey
+        },
+        body: json,
+        // keepalive lets the request outlive the page in browsers that
+        // support it; it is ignored elsewhere.
+        keepalive: opts.beacon === true,
+        signal: controller ? controller.signal : void 0,
+        // Never send the site's cookies to Bugban.
+        credentials: "omit",
+        mode: "cors"
+      });
+      if (timer) clearTimeout(timer);
+      if (!res.ok) this.log("ingest rejected", res.status);
+      return res.ok;
+    } catch (e) {
+      this.log("fetch failed", e);
+      return false;
+    }
+  }
+  /**
+   * Node without global fetch — that is Node 17 and older, which a fair
+   * number of customers still run in production. Uses the http/https module
+   * loaded the bundler-opaque way, because `globalThis.require` does not
+   * exist under ESM and this path would otherwise silently deliver nothing.
+   */
+  async viaNodeHttp(url, json, opts) {
+    const isHttps = url.indexOf("https://") === 0;
+    const mod = await nodeModule2(isHttps ? "https" : "http");
+    if (!mod || typeof mod.request !== "function") return false;
+    return new Promise((resolve) => {
+      var _a;
+      try {
+        const u = new URL(url);
+        const req = mod.request(
+          {
+            method: "POST",
+            hostname: u.hostname,
+            port: u.port || (isHttps ? 443 : 80),
+            path: u.pathname + u.search,
+            timeout: (_a = opts.timeoutMs) != null ? _a : 8e3,
+            headers: {
+              "Content-Type": "application/json",
+              // Byte length, not string length — a multi-byte
+              // message would otherwise truncate the body.
+              "Content-Length": byteLength(json),
+              "X-Bugban-Key": this.apiKey
+            }
+          },
+          (res) => {
+            res.resume();
+            resolve(res.statusCode >= 200 && res.statusCode < 300);
+          }
+        );
+        req.on("error", () => resolve(false));
+        req.on("timeout", () => {
+          safe(() => req.destroy());
+          resolve(false);
+        });
+        req.write(json);
+        req.end();
+      } catch (e) {
+        resolve(false);
+      }
+    });
+  }
+  log(...args) {
+    if (!this.debug) return;
+    safe(() => console.warn("[bugban]", ...args));
+  }
+};
+
+// src/breadcrumbs.ts
+var BreadcrumbBuffer = class {
+  constructor(max) {
+    this.max = max;
+    this.items = [];
+  }
+  add(crumb) {
+    try {
+      const full = {
+        type: crumb.type,
+        message: crumb.message,
+        level: crumb.level,
+        data: crumb.data,
+        timestamp: crumb.timestamp || nowIso()
+      };
+      this.items.push(full);
+      if (this.items.length > this.max) {
+        this.items.splice(0, this.items.length - this.max);
+      }
+    } catch (e) {
+    }
+  }
+  /** Snapshot for sending. Copied so a later push cannot mutate a sent event. */
+  all() {
+    return this.items.slice();
+  }
+  clear() {
+    this.items = [];
+  }
+  setMax(max) {
+    this.max = max;
+    if (this.items.length > max) {
+      this.items.splice(0, this.items.length - max);
+    }
+  }
+};
+
+// src/stacktrace.ts
+var V8_LINE = /^\s*at (?:(.+?)\s+\()?(?:(.+?):(\d+):(\d+)|([^)]+))\)?\s*$/;
+var MOZ_LINE = /^\s*(?:(.*?)@)?(.+?):(\d+):(\d+)\s*$/;
+var VENDOR_PATTERNS = [
+  "node_modules",
+  "webpack-internal",
+  "webpack://",
+  "/.next/",
+  "/.nuxt/",
+  "node:internal",
+  "internal/process"
+];
+function isInApp(file) {
+  if (!file) return false;
+  for (const p of VENDOR_PATTERNS) {
+    if (file.indexOf(p) !== -1) return false;
+  }
+  return true;
+}
+function toFrame(fn, file, line, col) {
+  const f = {
+    file: file || void 0,
+    line: line ? parseInt(line, 10) : void 0,
+    column: col ? parseInt(col, 10) : void 0,
+    in_app: isInApp(file)
+  };
+  if (fn && fn !== "<anonymous>") f.function = fn.trim();
+  return f;
+}
+function parseStack(stack, limit = 50) {
+  if (typeof stack !== "string" || stack === "") return [];
+  const frames = [];
+  const lines = stack.split("\n");
+  for (const raw of lines) {
+    if (frames.length >= limit) break;
+    const line = raw.replace(/\r$/, "");
+    if (!line.trim()) continue;
+    if (!/^\s*at\s/.test(line) && line.indexOf("@") === -1) continue;
+    let m = V8_LINE.exec(line);
+    if (m) {
+      if (m[5] && !m[2]) {
+        const loc = /^(.*?):(\d+):(\d+)$/.exec(m[5]);
+        frames.push(
+          loc ? toFrame(m[1], loc[1], loc[2], loc[3]) : { function: m[1], file: m[5], in_app: isInApp(m[5]) }
+        );
+      } else {
+        frames.push(toFrame(m[1], m[2] || "", m[3] || "", m[4] || ""));
+      }
+      continue;
+    }
+    m = MOZ_LINE.exec(line);
+    if (m) {
+      frames.push(toFrame(m[1], m[2] || "", m[3] || "", m[4] || ""));
+      continue;
+    }
+    frames.push({ function: line.trim(), in_app: false });
+  }
+  return frames;
+}
+function normalizeError(input) {
+  if (input instanceof Error) {
+    return {
+      name: input.name || "Error",
+      message: input.message || String(input),
+      stack: input.stack
+    };
+  }
+  if (typeof input === "string") return { name: "Error", message: input };
+  if (input && typeof input === "object") {
+    const o = input;
+    if (typeof o.message === "string") {
+      return {
+        name: typeof o.name === "string" ? o.name : "Error",
+        message: o.message,
+        stack: typeof o.stack === "string" ? o.stack : void 0
+      };
+    }
+    try {
+      return { name: "Error", message: JSON.stringify(o) };
+    } catch (e) {
+      return { name: "Error", message: "[object]" };
+    }
+  }
+  return { name: "Error", message: String(input) };
+}
+
+// src/snapshot.ts
+var MASK_CHAR = "\u2022";
+var DROP_TAGS = ["SCRIPT", "NOSCRIPT", "TEMPLATE"];
+function maskValue(value) {
+  const len = Math.min(value.length, 12);
+  return len > 0 ? MASK_CHAR.repeat(len) : "";
+}
+function maskFormFields(root) {
+  const fields = root.querySelectorAll("input, textarea, select");
+  for (let i = 0; i < fields.length; i++) {
+    const el = fields[i];
+    try {
+      const type = (el.getAttribute("type") || "").toLowerCase();
+      if (type === "password") {
+        el.setAttribute("value", MASK_CHAR.repeat(8));
+        continue;
+      }
+      if (type === "checkbox" || type === "radio" || type === "submit" || type === "button") {
+        continue;
+      }
+      const current = el.getAttribute("value") || "";
+      if (current) el.setAttribute("value", maskValue(current));
+      if (el.tagName === "TEXTAREA" && el.textContent) {
+        el.textContent = maskValue(el.textContent);
+      }
+    } catch (e) {
+    }
+  }
+}
+function maskSelectors(root, selectors) {
+  for (const sel of selectors) {
+    try {
+      const nodes = root.querySelectorAll(sel);
+      for (let i = 0; i < nodes.length; i++) {
+        const el = nodes[i];
+        if (el.textContent) el.textContent = MASK_CHAR.repeat(6);
+      }
+    } catch (e) {
+    }
+  }
+}
+function materializeFormState(source, clone) {
+  try {
+    const src = source.querySelectorAll("input, textarea, select");
+    const dst = clone.querySelectorAll("input, textarea, select");
+    const n = Math.min(src.length, dst.length);
+    for (let i = 0; i < n; i++) {
+      const s = src[i];
+      const d = dst[i];
+      if (s.tagName === "SELECT") {
+        d.setAttribute("data-bugban-selected", String(s.selectedIndex));
+        continue;
+      }
+      if (typeof s.value === "string" && s.value !== "") d.setAttribute("value", s.value);
+      if (s.checked) d.setAttribute("checked", "checked");
+    }
+  } catch (e) {
+  }
+}
+function collectCss(maxBytes) {
+  let css = "";
+  try {
+    const sheets = document.styleSheets;
+    for (let i = 0; i < sheets.length; i++) {
+      if (css.length > maxBytes) break;
+      try {
+        const rules = sheets[i].cssRules;
+        if (!rules) continue;
+        for (let j = 0; j < rules.length; j++) {
+          css += rules[j].cssText + "\n";
+          if (css.length > maxBytes) break;
+        }
+      } catch (e) {
+        continue;
+      }
+    }
+  } catch (e) {
+  }
+  return css.length > maxBytes ? css.slice(0, maxBytes) : css;
+}
+function takeSnapshot(opts) {
+  if (!isBrowser || !opts.enabled) return null;
+  try {
+    const source = document.documentElement;
+    if (!source) return null;
+    const clone = source.cloneNode(true);
+    materializeFormState(source, clone);
+    if (opts.maskInputs) maskFormFields(clone);
+    if (opts.maskSelectors && opts.maskSelectors.length) {
+      maskSelectors(clone, opts.maskSelectors);
+    }
+    for (const tag of DROP_TAGS) {
+      const nodes = clone.getElementsByTagName(tag);
+      while (nodes.length > 0) {
+        const n = nodes[0];
+        if (n.parentNode) n.parentNode.removeChild(n);
+        else break;
+      }
+    }
+    try {
+      const head = clone.querySelector("head");
+      if (head && !head.querySelector("base")) {
+        const base = document.createElement("base");
+        base.setAttribute("href", document.baseURI || location.href);
+        head.insertBefore(base, head.firstChild);
+      }
+    } catch (e) {
+    }
+    let html = clone.outerHTML || "";
+    if (html.length > opts.maxBytes) {
+      return null;
+    }
+    const css = collectCss(Math.max(0, opts.maxBytes - html.length));
+    return {
+      kind: "dom",
+      html,
+      css: css || void 0,
+      viewport: {
+        width: window.innerWidth,
+        height: window.innerHeight,
+        scrollX: window.scrollX || 0,
+        scrollY: window.scrollY || 0
+      },
+      url: location.href,
+      taken_at: nowIso()
+    };
+  } catch (e) {
+    return null;
+  }
+}
+
+// src/vitals.ts
+var THRESHOLDS = {
+  LCP: [2500, 4e3],
+  FCP: [1800, 3e3],
+  CLS: [0.1, 0.25],
+  INP: [200, 500],
+  TTFB: [800, 1800]
+};
+function rate(name, value) {
+  const t = THRESHOLDS[name];
+  if (!t) return void 0;
+  if (value <= t[0]) return "good";
+  if (value <= t[1]) return "needs-improvement";
+  return "poor";
+}
+var VitalsCollector = class {
+  constructor(opts, flush2) {
+    this.opts = opts;
+    this.flush = flush2;
+    this.metrics = [];
+    this.observers = [];
+    this.flushed = false;
+    /** LCP/CLS/INP are "final value wins" — keyed so later values replace. */
+    this.latest = {};
+  }
+  start() {
+    if (!isBrowser || !this.opts.enabled) return;
+    if (typeof PerformanceObserver !== "function") return;
+    this.observeTtfb();
+    this.observePaint();
+    this.observeLcp();
+    this.observeCls();
+    this.observeInp();
+    this.observeLongTasks();
+    this.observeResources();
+    this.installFlushTriggers();
+  }
+  stop() {
+    for (const o of this.observers) safe(() => o.disconnect());
+    this.observers = [];
+  }
+  /** Manually add a metric — adapters use this for component render times. */
+  push(metric) {
+    var _a, _b, _c;
+    try {
+      this.metrics.push({
+        ...metric,
+        rating: (_a = metric.rating) != null ? _a : rate(metric.name, metric.value),
+        url: (_b = metric.url) != null ? _b : location.href,
+        occurred_at: (_c = metric.occurred_at) != null ? _c : nowIso()
+      });
+    } catch (e) {
+    }
+  }
+  set(name, value, extra = {}) {
+    this.latest[name] = {
+      name,
+      value: Math.round(value * 1e3) / 1e3,
+      rating: rate(name, value),
+      url: safe(() => location.href),
+      occurred_at: nowIso(),
+      ...extra
+    };
+  }
+  observe(type, cb, buffered = true) {
+    safe(() => {
+      const obs = new PerformanceObserver((list) => safe(() => cb(list.getEntries())));
+      obs.observe({ type, buffered });
+      this.observers.push(obs);
+    });
+  }
+  observeTtfb() {
+    safe(() => {
+      const nav = performance.getEntriesByType("navigation")[0];
+      if (nav && typeof nav.responseStart === "number" && nav.responseStart > 0) {
+        this.set("TTFB", nav.responseStart, { navigation_type: nav.type });
+      }
+    });
+  }
+  observePaint() {
+    this.observe("paint", (entries) => {
+      for (const e of entries) {
+        if (e.name === "first-contentful-paint") this.set("FCP", e.startTime);
+      }
+    });
+  }
+  observeLcp() {
+    this.observe("largest-contentful-paint", (entries) => {
+      const last = entries[entries.length - 1];
+      if (!last) return;
+      this.set("LCP", last.startTime, {
+        target: selectorFor(last.element),
+        data: { size: last.size, url: last.url || void 0 }
+      });
+    });
+  }
+  observeCls() {
+    let clsValue = 0;
+    let sessionValue = 0;
+    let sessionEntries = [];
+    this.observe("layout-shift", (entries) => {
+      var _a;
+      for (const entry of entries) {
+        if (entry.hadRecentInput) continue;
+        const first = sessionEntries[0];
+        const last = sessionEntries[sessionEntries.length - 1];
+        if (sessionValue && entry.startTime - last.startTime < 1e3 && entry.startTime - first.startTime < 5e3) {
+          sessionValue += entry.value;
+          sessionEntries.push(entry);
+        } else {
+          sessionValue = entry.value;
+          sessionEntries = [entry];
+        }
+        if (sessionValue > clsValue) {
+          clsValue = sessionValue;
+          const worst = sessionEntries.slice().sort((a, b) => b.value - a.value)[0];
+          this.set("CLS", clsValue, {
+            target: ((_a = worst == null ? void 0 : worst.sources) == null ? void 0 : _a[0]) ? selectorFor(worst.sources[0].node) : void 0
+          });
+        }
+      }
+    });
+  }
+  observeInp() {
+    let worst = 0;
+    this.observe("event", (entries) => {
+      for (const entry of entries) {
+        const duration = entry.duration;
+        if (typeof duration !== "number" || duration <= worst) continue;
+        worst = duration;
+        this.set("INP", duration, {
+          target: selectorFor(entry.target),
+          data: { interaction: entry.name }
+        });
+      }
+    });
+  }
+  observeLongTasks() {
+    this.observe("longtask", (entries) => {
+      var _a, _b;
+      for (const e of entries) {
+        if (e.duration < this.opts.longTaskMs) continue;
+        this.push({
+          name: "LONG_TASK",
+          value: Math.round(e.duration),
+          rating: e.duration > 200 ? "poor" : "needs-improvement",
+          target: ((_b = (_a = e.attribution) == null ? void 0 : _a[0]) == null ? void 0 : _b.containerName) || void 0,
+          data: { start: Math.round(e.startTime) }
+        });
+      }
+    });
+  }
+  observeResources() {
+    this.observe("resource", (entries) => {
+      for (const e of entries) {
+        if (e.duration < this.opts.slowResourceMs) continue;
+        if (e.name.indexOf("/api/ingest/") !== -1) continue;
+        this.push({
+          name: "RESOURCE",
+          value: Math.round(e.duration),
+          rating: e.duration > 3e3 ? "poor" : "needs-improvement",
+          target: e.name,
+          data: {
+            type: e.initiatorType,
+            size: e.transferSize || void 0,
+            cached: e.transferSize === 0 && e.decodedBodySize > 0
+          }
+        });
+      }
+    });
+  }
+  /**
+   * Flush when the page is hidden. `visibilitychange` fires reliably on
+   * mobile where `beforeunload` often does not; `pagehide` covers bfcache.
+   */
+  installFlushTriggers() {
+    const doFlush = () => this.flushNow();
+    safe(() => {
+      document.addEventListener(
+        "visibilitychange",
+        () => {
+          if (document.visibilityState === "hidden") doFlush();
+        },
+        { capture: true }
+      );
+      window.addEventListener("pagehide", doFlush, { capture: true });
+    });
+  }
+  flushNow() {
+    if (this.flushed) return;
+    try {
+      const all = this.metrics.concat(Object.keys(this.latest).map((k) => this.latest[k]));
+      if (all.length === 0) return;
+      this.flushed = true;
+      this.metrics = [];
+      this.latest = {};
+      this.flush(all);
+    } catch (e) {
+    }
+  }
+};
+
+// src/integrations/console.ts
+var LEVEL_MAP = {
+  log: "info",
+  info: "info",
+  debug: "debug",
+  warn: "warning",
+  error: "error"
+};
+function installConsole(opts, hooks) {
+  if (typeof console === "undefined") return () => {
+  };
+  const originals = {};
+  let inside = false;
+  for (const method of opts.levels) {
+    const original = console[method];
+    if (typeof original !== "function") continue;
+    originals[method] = original;
+    console[method] = function(...args) {
+      try {
+        if (!inside) {
+          inside = true;
+          const level = LEVEL_MAP[method] || "info";
+          const message = args.map((a) => typeof a === "string" ? a : truncate(a, 200)).join(" ");
+          hooks.breadcrumb(level, truncate(message, 500), args);
+          if ((method === "error" || method === "warn") && opts.captureAsEvent.indexOf(method) !== -1) {
+            hooks.capture(level, message, args);
+          }
+          inside = false;
+        }
+      } catch (e) {
+        inside = false;
+      }
+      return safe(() => original.apply(console, args));
+    };
+  }
+  return () => {
+    for (const m in originals) {
+      safe(() => {
+        console[m] = originals[m];
+      });
+    }
+  };
+}
+
+// src/redact.ts
+var DEFAULT_REDACT_KEYS = [
+  "password",
+  "passwd",
+  "pwd",
+  "secret",
+  "token",
+  "access_token",
+  "refresh_token",
+  "api_key",
+  "apikey",
+  "authorization",
+  "auth",
+  "cookie",
+  "set-cookie",
+  "session",
+  "csrf",
+  "xsrf",
+  "card",
+  "card_number",
+  "cardnumber",
+  "cvv",
+  "cvc",
+  "pin",
+  "ssn",
+  "iban"
+];
+var REDACTED = "[redacted]";
+function isSensitiveKey(key, extra) {
+  const k = key.toLowerCase();
+  for (const s of DEFAULT_REDACT_KEYS) {
+    if (k.indexOf(s) !== -1) return true;
+  }
+  for (const s of extra) {
+    if (s && k.indexOf(s.toLowerCase()) !== -1) return true;
+  }
+  return false;
+}
+function redact(value, extraKeys = [], depth = 0) {
+  if (depth > 6 || value == null) return value;
+  try {
+    if (Array.isArray(value)) {
+      return value.slice(0, 100).map((v) => redact(v, extraKeys, depth + 1));
+    }
+    if (typeof value === "object") {
+      const src = value;
+      const out = {};
+      let count = 0;
+      for (const key in src) {
+        if (!Object.prototype.hasOwnProperty.call(src, key)) continue;
+        if (++count > 100) break;
+        out[key] = isSensitiveKey(key, extraKeys) ? REDACTED : redact(src[key], extraKeys, depth + 1);
+      }
+      return out;
+    }
+  } catch (e) {
+  }
+  return value;
+}
+function redactUrl(url, extraKeys = []) {
+  try {
+    const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(url);
+    const u = new URL(url, hasScheme ? void 0 : "http://localhost");
+    if (u.username || u.password) {
+      u.username = "";
+      u.password = "";
+    }
+    u.searchParams.forEach((_v, k) => {
+      if (isSensitiveKey(k, extraKeys)) u.searchParams.set(k, REDACTED);
+    });
+    return hasScheme ? u.toString() : u.pathname + u.search + u.hash;
+  } catch (e) {
+    return url;
+  }
+}
+
+// src/integrations/network.ts
+function installNetwork(opts, hooks, redactKeys, ownHost) {
+  const undo = [];
+  const ignored = (url) => {
+    if (url.indexOf("/api/ingest/") !== -1) return true;
+    if (ownHost && url.indexOf(ownHost) === 0) return true;
+    return matchesAny(url, opts.ignoreUrls);
+  };
+  const record = (method, rawUrl, status, startedAt, errored) => {
+    try {
+      const url = redactUrl(rawUrl, redactKeys);
+      const duration = Math.round(now() - startedAt);
+      const failed = errored || typeof status === "number" && status >= 400;
+      const data = {
+        method,
+        url,
+        status_code: status,
+        duration_ms: duration
+      };
+      const label = `${method} ${url} \u2192 ${errored ? "failed" : status} (${duration}ms)`;
+      hooks.breadcrumb(label, data, failed);
+      if (opts.captureFailures && (errored || status !== void 0 && status >= 500)) {
+        hooks.capture(label, data);
+      }
+    } catch (e) {
+    }
+  };
+  if (opts.enabled && typeof fetch === "function") {
+    const original = fetch;
+    const patched = function(input, init2) {
+      let url = "";
+      let method = "GET";
+      const started = now();
+      try {
+        url = typeof input === "string" ? input : input && input.url ? input.url : String(input);
+        method = String(init2 && init2.method || input && input.method || "GET").toUpperCase();
+      } catch (e) {
+      }
+      if (!url || ignored(url)) return original.apply(this, [input, init2]);
+      return original.apply(this, [input, init2]).then(
+        (res) => {
+          record(method, url, res ? res.status : void 0, started, false);
+          return res;
+        },
+        (err) => {
+          record(method, url, void 0, started, true);
+          throw err;
+        }
+      );
+    };
+    globalThis.fetch = patched;
+    undo.push(() => {
+      globalThis.fetch = original;
+    });
+  }
+  if (opts.enabled && typeof XMLHttpRequest === "function") {
+    const proto = XMLHttpRequest.prototype;
+    const origOpen = proto.open;
+    const origSend = proto.send;
+    proto.open = function(method, url, ...rest) {
+      safe(() => {
+        this.__bugban = { method: String(method || "GET").toUpperCase(), url: String(url || "") };
+      });
+      return origOpen.apply(this, [method, url, ...rest]);
+    };
+    proto.send = function(...args) {
+      const meta = safe(() => this.__bugban);
+      if (meta && meta.url && !ignored(meta.url)) {
+        const started = now();
+        safe(() => {
+          this.addEventListener("loadend", () => {
+            const status = this.status || void 0;
+            record(meta.method, meta.url, status, started, !status);
+          });
+        });
+      }
+      return origSend.apply(this, args);
+    };
+    undo.push(() => {
+      proto.open = origOpen;
+      proto.send = origSend;
+    });
+  }
+  return () => {
+    for (const fn of undo) safe(fn);
+  };
+}
+function now() {
+  try {
+    return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+  } catch (e) {
+    return Date.now();
+  }
+}
+
+// src/integrations/globals.ts
+function installGlobalHandlers(hooks) {
+  const undo = [];
+  if (isBrowser) {
+    const onError = (event) => {
+      safe(() => {
+        const err = event.error || {
+          name: "Error",
+          message: event.message,
+          stack: void 0
+        };
+        hooks.capture(err, { handled: false, type: "onerror" });
+      });
+    };
+    const onRejection = (event) => {
+      safe(() => {
+        const reason = event.reason;
+        hooks.capture(reason, { handled: false, type: "unhandledrejection" });
+      });
+    };
+    safe(() => window.addEventListener("error", onError, true));
+    safe(() => window.addEventListener("unhandledrejection", onRejection, true));
+    undo.push(() => {
+      safe(() => window.removeEventListener("error", onError, true));
+      safe(() => window.removeEventListener("unhandledrejection", onRejection, true));
+    });
+  }
+  if (isNode) {
+    const onUncaught = (err) => {
+      hooks.capture(err, { handled: false, type: "uncaughtException" });
+      safe(() => {
+        void hooks.flush().then(() => {
+          if (process.listenerCount("uncaughtException") <= 1) {
+            process.exit(1);
+          }
+        });
+      });
+    };
+    const onUnhandled = (reason) => {
+      hooks.capture(reason, { handled: false, type: "unhandledRejection" });
+    };
+    safe(() => process.on("uncaughtException", onUncaught));
+    safe(() => process.on("unhandledRejection", onUnhandled));
+    safe(() => process.on("beforeExit", () => void hooks.flush()));
+    undo.push(() => {
+      safe(() => process.off("uncaughtException", onUncaught));
+      safe(() => process.off("unhandledRejection", onUnhandled));
+    });
+  }
+  return () => {
+    for (const fn of undo) safe(fn);
+  };
+}
+
+// src/integrations/dom.ts
+function labelFor(el) {
+  return safe(() => {
+    const aria = el.getAttribute("aria-label");
+    if (aria) return truncate(aria, 60);
+    const tag = el.tagName.toLowerCase();
+    if (tag === "input" || tag === "textarea" || tag === "select") {
+      const ph = el.getAttribute("placeholder") || el.getAttribute("name") || "";
+      return ph ? `${tag}[${truncate(ph, 40)}]` : tag;
+    }
+    const text = (el.textContent || "").trim().replace(/\s+/g, " ");
+    return text ? truncate(text, 60) : tag;
+  }) || "element";
+}
+function installDomBreadcrumbs(hooks) {
+  if (!isBrowser) return () => {
+  };
+  const undo = [];
+  const onClick = (event) => {
+    safe(() => {
+      const target = event.target;
+      if (!target || typeof target.tagName !== "string") return;
+      let el = target;
+      for (let i = 0; i < 4 && el; i++) {
+        const tag = el.tagName.toLowerCase();
+        if (tag === "button" || tag === "a" || el.getAttribute("role") === "button") break;
+        el = el.parentElement;
+      }
+      const chosen = el || target;
+      hooks.click(labelFor(chosen), {
+        selector: selectorFor(chosen),
+        href: safe(() => chosen.getAttribute("href")) || void 0
+      });
+    });
+  };
+  safe(() => document.addEventListener("click", onClick, { capture: true, passive: true }));
+  undo.push(() => safe(() => document.removeEventListener("click", onClick, true)));
+  let current = safe(() => location.href) || "";
+  const report = () => {
+    safe(() => {
+      const next = location.href;
+      if (next !== current) {
+        hooks.navigate(current, next);
+        current = next;
+      }
+    });
+  };
+  safe(() => {
+    const history = window.history;
+    const origPush = history.pushState;
+    const origReplace = history.replaceState;
+    if (typeof origPush === "function") {
+      history.pushState = function(...args) {
+        const r = origPush.apply(this, args);
+        report();
+        return r;
+      };
+      undo.push(() => {
+        history.pushState = origPush;
+      });
+    }
+    if (typeof origReplace === "function") {
+      history.replaceState = function(...args) {
+        const r = origReplace.apply(this, args);
+        report();
+        return r;
+      };
+      undo.push(() => {
+        history.replaceState = origReplace;
+      });
+    }
+  });
+  safe(() => window.addEventListener("popstate", report));
+  undo.push(() => safe(() => window.removeEventListener("popstate", report)));
+  return () => {
+    for (const fn of undo) safe(fn);
+  };
+}
+
+// src/ping.ts
+var MARKER_KEY = "bugban.ping";
+var memoryMarker = false;
+async function alreadyPinged(apiKey, version) {
+  const stamp = `${apiKey.slice(0, 12)}:${version}`;
+  if (isBrowser) {
+    const stored = safe(() => localStorage.getItem(MARKER_KEY));
+    if (stored === stamp) return true;
+    safe(() => localStorage.setItem(MARKER_KEY, stamp));
+    if (memoryMarker) return true;
+    memoryMarker = true;
+    return false;
+  }
+  if (isNode) {
+    try {
+      const [fs, os, path] = await Promise.all([
+        nodeModule("fs"),
+        nodeModule("os"),
+        nodeModule("path")
+      ]);
+      if (!fs || !os || !path || typeof fs.existsSync !== "function") {
+        if (memoryMarker) return true;
+        memoryMarker = true;
+        return false;
+      }
+      const key = toHex(stamp).slice(0, 32);
+      const file = path.join(os.tmpdir(), `.bugban-ping-${key}`);
+      if (fs.existsSync(file)) return true;
+      fs.writeFileSync(file, stamp);
+      return false;
+    } catch (e) {
+      return false;
+    }
+  }
+  if (memoryMarker) return true;
+  memoryMarker = true;
+  return false;
+}
+function toHex(s) {
+  let out = "";
+  for (let i = 0; i < s.length; i++) {
+    out += s.charCodeAt(i).toString(16);
+  }
+  return out;
+}
+async function sendInstallPing(opts, transport) {
+  if (!opts.installPing || !opts.enabled) return;
+  try {
+    if (await alreadyPinged(opts.apiKey, SDK_VERSION)) return;
+    const pkg = await appPackageInfo();
+    const host = await hostname();
+    const payload = {
+      sdk: SDK_NAME,
+      sdk_version: SDK_VERSION,
+      framework: opts.framework || runtimeName(),
+      framework_version: opts.frameworkVersion,
+      environment: opts.environment,
+      hostname: host,
+      // The app's own identity. In Node this is read from package.json; in
+      // the browser there is no filesystem, so it comes from `release`
+      // (usually wired to the bundler's define) and the page host.
+      app_name: pkg.name || (isBrowser ? safe(() => location.hostname) : void 0),
+      app_version: opts.release || pkg.version,
+      // Where the SDK is running, and that runtime's version: Node's
+      // process.version, or the browser UA. The panel shows this the same
+      // way it shows the PHP version for the PHP SDKs.
+      runtime: runtimeName(),
+      runtime_version: runtimeVersion()
+    };
+    for (const k in payload) {
+      if (payload[k] == null || payload[k] === "") delete payload[k];
+    }
+    void transport.send("/api/ingest/ping", payload);
+  } catch (e) {
+  }
+}
+
+// src/client.ts
+var BugbanClient = class {
+  constructor(options = {}) {
+    this.teardown = [];
+    this.user = null;
+    this.context = {};
+    this.sessionId = randomId();
+    this.startedAt = Date.now();
+    /** Events waiting to be sent, coalesced so an error storm is one request. */
+    this.queue = [];
+    this.flushTimer = null;
+    /** Guard against reporting an error that our own reporting caused. */
+    this.sending = false;
+    this.started = false;
+    this.opts = resolveOptions(options);
+    this.transport = new Transport(this.opts.host, this.opts.apiKey, this.opts.debug);
+    this.crumbs = new BreadcrumbBuffer(this.opts.maxBreadcrumbs);
+  }
+  get options() {
+    return this.opts;
+  }
+  /** Wire up integrations. Safe to call twice — the second call is ignored. */
+  start() {
+    if (this.started) return;
+    this.started = true;
+    if (!this.opts.enabled) {
+      this.debug("disabled (no API key)");
+      return;
+    }
+    safe(() => this.installIntegrations());
+    safe(() => sendInstallPing(this.opts, this.transport));
+  }
+  installIntegrations() {
+    const o = this.opts;
+    if (o.globalHandlers) {
+      this.teardown.push(
+        installGlobalHandlers({
+          capture: (err, extra) => this.capture(err, extra),
+          flush: () => this.flush()
+        })
+      );
+    }
+    if (o.console) {
+      this.teardown.push(
+        installConsole(o.console, {
+          breadcrumb: (level, message) => this.addBreadcrumb({ type: "console", level, message }),
+          capture: (level, message, args) => {
+            const real = args.find((a) => a instanceof Error);
+            this.capture(real != null ? real : message, {
+              handled: true,
+              type: "console",
+              level
+            });
+          }
+        })
+      );
+    }
+    if (o.network) {
+      this.teardown.push(
+        installNetwork(
+          o.network,
+          {
+            breadcrumb: (message, data, failed) => this.addBreadcrumb({
+              type: "http",
+              level: failed ? "error" : "info",
+              message,
+              data
+            }),
+            capture: (message, data) => this.capture(new Error(message), {
+              handled: true,
+              type: "http",
+              context: data
+            })
+          },
+          o.redactKeys,
+          o.host
+        )
+      );
+    }
+    if (o.domBreadcrumbs) {
+      this.teardown.push(
+        installDomBreadcrumbs({
+          click: (label, data) => this.addBreadcrumb({ type: "click", message: `Clicked ${label}`, data }),
+          navigate: (from, to) => this.addBreadcrumb({
+            type: "navigation",
+            message: `${redactUrl(from, o.redactKeys)} \u2192 ${redactUrl(to, o.redactKeys)}`
+          })
+        })
+      );
+    }
+    if (o.vitals && isBrowser) {
+      if (sampled(o.vitals.sampleRate)) {
+        this.vitals = new VitalsCollector(o.vitals, (metrics) => this.sendVitals(metrics));
+        this.vitals.start();
+        this.teardown.push(() => {
+          var _a;
+          return (_a = this.vitals) == null ? void 0 : _a.stop();
+        });
+      } else {
+        this.debug("vitals not sampled for this session");
+      }
+    }
+    if (isBrowser) {
+      this.teardown.push(this.installUnloadFlush());
+    }
+  }
+  /**
+   * Send whatever is queued before the page goes away.
+   *
+   * Events are batched with a short debounce so an error loop becomes one
+   * request instead of hundreds. That debounce loses the last batch whenever
+   * the user navigates immediately after the error — which is the common
+   * case, not an edge case: click a link, something throws, the document is
+   * torn down before the timer fires. Observed exactly that while testing:
+   * an uncaught TypeError never arrived while the beacon-based vitals from the
+   * same page did.
+   *
+   * `visibilitychange` is the reliable signal (mobile Safari often skips
+   * `beforeunload`), and `pagehide` covers the bfcache case. Both drain with
+   * `beacon: true`, the only delivery a closing document is guaranteed to
+   * complete.
+   */
+  installUnloadFlush() {
+    const onHide = () => {
+      if (document.visibilityState === "hidden") void this.drain(true);
+    };
+    const onPageHide = () => void this.drain(true);
+    safe(() => document.addEventListener("visibilitychange", onHide, true));
+    safe(() => window.addEventListener("pagehide", onPageHide, true));
+    return () => {
+      safe(() => document.removeEventListener("visibilitychange", onHide, true));
+      safe(() => window.removeEventListener("pagehide", onPageHide, true));
+    };
+  }
+  // --- public API ---------------------------------------------------------
+  addBreadcrumb(crumb) {
+    if (!this.opts.enabled) return;
+    safe(() => {
+      let c = {
+        ...crumb,
+        data: crumb.data ? redact(crumb.data, this.opts.redactKeys) : void 0,
+        timestamp: crumb.timestamp || nowIso()
+      };
+      if (this.opts.beforeBreadcrumb) {
+        const out = this.opts.beforeBreadcrumb(c);
+        if (!out) return;
+        c = out;
+      }
+      this.crumbs.add(c);
+    });
+  }
+  setUser(user) {
+    safe(() => {
+      this.user = user ? redact(user, this.opts.redactKeys) : null;
+    });
+  }
+  setContext(key, value) {
+    safe(() => {
+      this.context[key] = redact(value, this.opts.redactKeys);
+    });
+  }
+  captureMessage(message, level = "info") {
+    this.capture(new Error(message), { handled: true, level, type: "message" });
+  }
+  /** Report an error. Never throws, never blocks. */
+  capture(error, extra = {}) {
+    if (!this.opts.enabled) return;
+    if (this.sending) return;
+    safe(() => {
+      var _a;
+      const norm = normalizeError(error);
+      if (this.opts.ignoreErrors.length && matchesAny(norm.message, this.opts.ignoreErrors)) {
+        return;
+      }
+      if (!sampled(this.opts.sampleRate)) return;
+      const frames = parseStack(norm.stack);
+      const top = frames.find((f) => f.in_app) || frames[0];
+      let event = {
+        exception_class: norm.name,
+        message: truncate(norm.message, 2e3),
+        level: extra.level || "error",
+        type: extra.type || "error",
+        handled: (_a = extra.handled) != null ? _a : true,
+        file: top == null ? void 0 : top.file,
+        line: top == null ? void 0 : top.line,
+        stacktrace: frames,
+        release: this.opts.release,
+        environment: this.opts.environment,
+        user: this.user,
+        breadcrumbs: this.crumbs.all(),
+        device: deviceInfo(),
+        session: {
+          id: this.sessionId,
+          started_at: new Date(this.startedAt).toISOString(),
+          duration_ms: Date.now() - this.startedAt
+        },
+        request: extra.request || this.requestInfo(),
+        context: {
+          ...this.context,
+          ...extra.context ? redact(extra.context, this.opts.redactKeys) : {}
+        },
+        snapshot: this.opts.snapshot ? takeSnapshot(this.opts.snapshot) : null
+      };
+      if (this.opts.beforeSend) {
+        const out = this.opts.beforeSend(event);
+        if (!out) return;
+        event = out;
+      }
+      this.enqueue(event);
+    });
+  }
+  /** Flush anything queued. Await it before a process exits. */
+  async flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.drain(false);
+    safe(() => {
+      var _a;
+      return (_a = this.vitals) == null ? void 0 : _a.flushNow();
+    });
+  }
+  /** Remove every hook the SDK installed. */
+  close() {
+    for (const fn of this.teardown) safe(fn);
+    this.teardown = [];
+    this.started = false;
+  }
+  /** Adapters use this to report render timings alongside browser vitals. */
+  recordMetric(metric) {
+    safe(() => {
+      var _a;
+      return (_a = this.vitals) == null ? void 0 : _a.push(metric);
+    });
+  }
+  // --- internals ----------------------------------------------------------
+  requestInfo() {
+    if (!isBrowser) return void 0;
+    return safe(() => ({
+      url: redactUrl(location.href, this.opts.redactKeys),
+      referrer: document.referrer ? redactUrl(document.referrer, this.opts.redactKeys) : void 0,
+      method: "GET"
+    }));
+  }
+  enqueue(event) {
+    this.queue.push(event);
+    if (this.queue.length > 50) this.queue.splice(0, this.queue.length - 50);
+    if (this.flushTimer) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      void this.drain(false);
+    }, 300);
+    safe(() => {
+      const t = this.flushTimer;
+      if (t && typeof t.unref === "function") t.unref();
+    });
+  }
+  async drain(beacon) {
+    if (this.queue.length === 0) return;
+    const batch = this.queue.splice(0, this.queue.length);
+    this.sending = true;
+    try {
+      await this.transport.send("/api/ingest/events", { events: batch }, { beacon });
+    } finally {
+      this.sending = false;
+    }
+  }
+  sendVitals(metrics) {
+    safe(() => {
+      const queries = [];
+      const vitals = [];
+      for (const m of metrics) {
+        if (m.name === "SLOW_QUERY") {
+          const d = m.data || {};
+          queries.push({
+            sql: d.sql,
+            duration_ms: m.value,
+            connection: d.connection,
+            bindings: d.bindings,
+            url: d.url,
+            method: d.method,
+            occurred_at: m.occurred_at
+          });
+        } else {
+          vitals.push(m);
+        }
+      }
+      const url = safe(() => redactUrl(location.href, this.opts.redactKeys));
+      if (queries.length) {
+        void this.transport.send("/api/ingest/queries", { queries }, { beacon: true });
+      }
+      if (vitals.length) {
+        void this.transport.send(
+          "/api/ingest/vitals",
+          {
+            vitals,
+            url,
+            release: this.opts.release,
+            environment: this.opts.environment,
+            session_id: this.sessionId,
+            device: deviceInfo()
+          },
+          // The page is usually unloading when vitals flush — beacon
+          // is the only delivery that survives that.
+          { beacon: true }
+        );
+      }
+    });
+  }
+  debug(...args) {
+    if (!this.opts.debug) return;
+    safe(() => console.info("[bugban]", ...args));
+  }
+};
+
+// src/index.ts
+var client = null;
+function init(options = {}) {
+  if (client) safe(() => client.close());
+  client = new BugbanClient(options);
+  client.start();
+  return client;
+}
+function getClient() {
+  return client;
+}
+function capture(error, extra) {
+  client == null ? void 0 : client.capture(error, extra);
+}
+function captureMessage(message, level = "info") {
+  client == null ? void 0 : client.captureMessage(message, level);
+}
+function setUser(user) {
+  client == null ? void 0 : client.setUser(user);
+}
+function setContext(key, value) {
+  client == null ? void 0 : client.setContext(key, value);
+}
+function addBreadcrumb(crumb) {
+  client == null ? void 0 : client.addBreadcrumb(crumb);
+}
+function recordMetric(metric) {
+  client == null ? void 0 : client.recordMetric(metric);
+}
+async function flush() {
+  await (client == null ? void 0 : client.flush());
+}
+function close() {
+  client == null ? void 0 : client.close();
+  client = null;
+}
+var Bugban = {
+  VERSION: SDK_VERSION,
+  init,
+  getClient,
+  capture,
+  captureMessage,
+  setUser,
+  setContext,
+  addBreadcrumb,
+  recordMetric,
+  flush,
+  close
+};
+
+exports.Bugban = Bugban;
+exports.BugbanClient = BugbanClient;
+exports.SDK_NAME = SDK_NAME;
+exports.SDK_VERSION = SDK_VERSION;
+exports.addBreadcrumb = addBreadcrumb;
+exports.capture = capture;
+exports.captureMessage = captureMessage;
+exports.close = close;
+exports.dependencyVersion = dependencyVersion;
+exports.flush = flush;
+exports.getClient = getClient;
+exports.init = init;
+exports.normalizeError = normalizeError;
+exports.parseStack = parseStack;
+exports.recordMetric = recordMetric;
+exports.redact = redact;
+exports.redactUrl = redactUrl;
+exports.runtimeName = runtimeName;
+exports.runtimeVersion = runtimeVersion;
+exports.setContext = setContext;
+exports.setUser = setUser;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map