@debugkit/sdk 0.1.0 → 0.3.0

package/dist/chunk-Q33W6RAG.cjs

@@ -0,0 +1,667 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// ../schema/src/core.ts
+var V8 = /^\s*at (?:(.+?) \()?(.+?):(\d+):(\d+)\)?\s*$/;
+var GECKO = /^\s*(.*?)@(.+?):(\d+):(\d+)\s*$/;
+var NOT_IN_APP = [/node_modules/, /\bnative\b/, /\[native code\]/, /InternalBytecode/];
+var RN_BUNDLE = /\.(?:js)?bundle\b/;
+function cleanFile(file) {
+  return file.replace(/^address at /, "");
+}
+function parseStack(stack) {
+  var _a;
+  if (!stack) return [];
+  const frames = [];
+  for (const raw of stack.split("\n")) {
+    const m = (_a = V8.exec(raw)) != null ? _a : GECKO.exec(raw);
+    if (!m) continue;
+    const [, fn, rawFile, line, col] = m;
+    const file = cleanFile(rawFile != null ? rawFile : "");
+    frames.push({
+      fn: fn || void 0,
+      file,
+      line: Number(line),
+      col: Number(col),
+      inApp: RN_BUNDLE.test(file) ? !/^(?:anonymous|eval|global code)$/.test(fn != null ? fn : "") : !NOT_IN_APP.some((re) => re.test(file))
+    });
+    if (frames.length >= 100) break;
+  }
+  return frames;
+}
+
+// src/context.ts
+function mergeContext(a, b) {
+  const out = { ...a };
+  for (const [k, v] of Object.entries(b)) {
+    const prev = out[k];
+    out[k] = v && typeof v === "object" && prev && typeof prev === "object" ? { ...prev, ...v } : v != null ? v : prev;
+  }
+  return out;
+}
+function safe(fn) {
+  try {
+    return fn();
+  } catch {
+    return void 0;
+  }
+}
+function timezone() {
+  return safe(() => Intl.DateTimeFormat().resolvedOptions().timeZone);
+}
+function locale() {
+  return safe(() => Intl.DateTimeFormat().resolvedOptions().locale);
+}
+function browserContext() {
+  var _a, _b, _c;
+  if (typeof navigator === "undefined" || typeof window === "undefined") {
+    const ua2 = typeof navigator !== "undefined" ? navigator.userAgent : void 0;
+    const node = typeof process !== "undefined" ? (_a = process.versions) == null ? void 0 : _a.node : void 0;
+    return {
+      runtime: { name: ua2 === "Cloudflare-Workers" ? "cloudflare-workers" : node ? "node" : "edge", version: node },
+      os: { name: "server" },
+      timezone: timezone()
+    };
+  }
+  const ua = navigator.userAgent;
+  const android = (_b = /Android ([\d.]+)/.exec(ua)) == null ? void 0 : _b[1];
+  const ios = (_c = /(?:iPhone|iPad|iPod).*? OS (\d+[_\d]*)/.exec(ua)) == null ? void 0 : _c[1];
+  const os = android ? { name: "android", version: android } : ios ? { name: "ios", version: ios.replace(/_/g, ".") } : /Mac OS X/.test(ua) ? { name: "macos" } : /Windows/.test(ua) ? { name: "windows" } : /Linux/.test(ua) ? { name: "linux" } : { name: "web" };
+  const conn = navigator.connection;
+  const browser = /Edg\/([\d.]+)/.exec(ua) ? { name: "edge", v: /Edg\/([\d.]+)/.exec(ua)[1] } : /Chrome\/([\d.]+)/.exec(ua) ? { name: "chrome", v: /Chrome\/([\d.]+)/.exec(ua)[1] } : /Version\/([\d.]+).*Safari/.exec(ua) ? { name: "safari", v: /Version\/([\d.]+)/.exec(ua)[1] } : /Firefox\/([\d.]+)/.exec(ua) ? { name: "firefox", v: /Firefox\/([\d.]+)/.exec(ua)[1] } : void 0;
+  return {
+    os,
+    runtime: { name: "browser", version: browser ? `${browser.name} ${browser.v}` : void 0 },
+    device: {
+      type: /iPad|Tablet/.test(ua) ? "tablet" : /Mobi/.test(ua) ? "phone" : "desktop",
+      screen: typeof screen !== "undefined" ? { width: screen.width, height: screen.height, scale: window.devicePixelRatio } : void 0
+    },
+    network: conn ? {
+      type: conn.type === "wifi" ? "wifi" : conn.type === "cellular" ? "cellular" : "unknown",
+      effectiveType: conn.effectiveType,
+      isConnected: navigator.onLine
+    } : void 0,
+    locale: navigator.language,
+    timezone: timezone()
+  };
+}
+
+// src/auto.ts
+var g = globalThis;
+var ID_SEGMENT = /^(?:\d+|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[0-9a-f]{16,}|(?=[^/]*\d)[\w-]{20,})$/i;
+function normaliseUrl(raw) {
+  var _a;
+  const m = /^(?:([a-z][a-z0-9+.-]*:)?\/\/([^/?#]*))?([^?#]*)/i.exec(raw.trim());
+  let host = (_a = m == null ? void 0 : m[2]) != null ? _a : "";
+  const path2 = ((m == null ? void 0 : m[3]) || "/").split("/").map((s) => ID_SEGMENT.test(s) ? ":id" : s).join("/");
+  if (host.includes("@")) host = host.slice(host.lastIndexOf("@") + 1);
+  const here = typeof location !== "undefined" ? location.host : void 0;
+  return !host || host === here ? path2 : `${host}${path2.startsWith("/") ? "" : "/"}${path2}`;
+}
+var insideFetch = 0;
+function instrumentFetch(sink) {
+  const orig = g.fetch;
+  if (typeof orig !== "function" || orig.__debug) return;
+  const wrapped = function(input, init) {
+    var _a, _b, _c, _d;
+    const url = typeof input === "string" ? input : (_b = (_a = input == null ? void 0 : input.href) != null ? _a : input == null ? void 0 : input.url) != null ? _b : String(input);
+    if (sink.ignored(url)) return orig.call(this, input, init);
+    const method = String((_d = (_c = init == null ? void 0 : init.method) != null ? _c : input == null ? void 0 : input.method) != null ? _d : "GET").toUpperCase();
+    const start = Date.now();
+    const stack = new Error().stack;
+    let p;
+    insideFetch++;
+    try {
+      p = orig.call(this, input, init);
+    } finally {
+      insideFetch--;
+    }
+    return p.then(
+      (res) => {
+        sink.request({ method, url, status: res.status, durationMs: Date.now() - start, stack });
+        return res;
+      },
+      (error) => {
+        const aborted = (error == null ? void 0 : error.name) === "AbortError";
+        sink.request({ method, url, error, aborted, durationMs: Date.now() - start, stack });
+        throw error;
+      }
+    );
+  };
+  wrapped.__debug = true;
+  g.fetch = wrapped;
+  return () => {
+    if (g.fetch === wrapped) g.fetch = orig;
+  };
+}
+function instrumentXhr(sink) {
+  const X = g.XMLHttpRequest;
+  const proto = X == null ? void 0 : X.prototype;
+  if (!proto || proto.open.__debug) return;
+  const open = proto.open;
+  const send = proto.send;
+  const wrappedOpen = function(method, url, ...rest) {
+    const u = String(url);
+    this.__debug = insideFetch > 0 || sink.ignored(u) ? null : { method: String(method).toUpperCase(), url: u };
+    return open.call(this, method, url, ...rest);
+  };
+  const wrappedSend = function(...args) {
+    const d = this.__debug;
+    if (d) {
+      const start = Date.now();
+      const stack = new Error().stack;
+      let aborted = false;
+      let timedOut = false;
+      this.addEventListener("abort", () => aborted = true);
+      this.addEventListener("timeout", () => timedOut = true);
+      this.addEventListener(
+        "loadend",
+        () => sink.request({ ...d, status: this.status || void 0, aborted, timedOut, durationMs: Date.now() - start, stack })
+      );
+    }
+    return send.apply(this, args);
+  };
+  wrappedOpen.__debug = true;
+  proto.open = wrappedOpen;
+  proto.send = wrappedSend;
+  return () => {
+    proto.open = open;
+    proto.send = send;
+  };
+}
+function format(arg) {
+  var _a;
+  if (typeof arg === "string") return arg;
+  if (arg instanceof Error) return `${arg.name}: ${arg.message}`;
+  try {
+    return (_a = JSON.stringify(arg)) != null ? _a : String(arg);
+  } catch {
+    return String(arg);
+  }
+}
+function instrumentConsole(sink) {
+  const c = g.console;
+  if (!c) return;
+  const restores = [];
+  for (const [method, level] of [["warn", "warning"], ["error", "error"]]) {
+    const orig = c[method];
+    if (typeof orig !== "function") continue;
+    c[method] = function(...args) {
+      if (args[0] !== "[deBug]") sink.crumb("log", args.map(format).join(" ").slice(0, 500), level);
+      return orig.apply(this, args);
+    };
+    restores.push(() => c[method] = orig);
+  }
+  return () => restores.forEach((r) => r());
+}
+var path = () => typeof location !== "undefined" ? location.pathname : "";
+function instrumentHistory(sink) {
+  const h = g.history;
+  if (typeof window === "undefined" || !(h == null ? void 0 : h.pushState) || typeof g.addEventListener !== "function") return;
+  const orig = { pushState: h.pushState, replaceState: h.replaceState };
+  for (const k of ["pushState", "replaceState"]) {
+    h[k] = function(...args) {
+      const out = orig[k].apply(this, args);
+      sink.navigated(path());
+      return out;
+    };
+  }
+  const onPop = () => sink.navigated(path());
+  g.addEventListener("popstate", onPop);
+  sink.navigated(path());
+  return () => {
+    Object.assign(h, orig);
+    g.removeEventListener("popstate", onPop);
+  };
+}
+var CLICKABLE = 'button,a,[role="button"],[role="link"],[role="tab"],[role="menuitem"],input[type="submit"],input[type="button"],input[type="checkbox"],input[type="radio"],summary,label,[data-testid]';
+function describeElement(el) {
+  const tag = el.tagName.toLowerCase();
+  const label = el.getAttribute("aria-label") || el.getAttribute("data-testid") || el.getAttribute("title") || (tag === "input" ? el.getAttribute("name") || el.type : el.innerText || el.textContent || "");
+  const id = el.id ? `#${el.id}` : "";
+  const text = label.replace(/\s+/g, " ").trim().slice(0, 60);
+  return `${tag}${id}${text ? ` "${text}"` : ""}`;
+}
+function instrumentClicks(sink) {
+  const d = g.document;
+  if (!(d == null ? void 0 : d.addEventListener)) return;
+  const onClick = (ev) => {
+    var _a;
+    const t = ev.target;
+    const el = (_a = t == null ? void 0 : t.closest) == null ? void 0 : _a.call(t, CLICKABLE);
+    if (el) sink.crumb("ui", `Clicked ${describeElement(el)}`);
+  };
+  d.addEventListener("click", onClick, true);
+  return () => d.removeEventListener("click", onClick, true);
+}
+function instrumentWebLifecycle(sink) {
+  const d = g.document;
+  if (typeof window === "undefined" || !(d == null ? void 0 : d.addEventListener)) return;
+  const onVis = () => sink.lifecycle(d.visibilityState === "hidden" ? "background" : "foreground");
+  const onOnline = () => sink.crumb("network", "Device went online");
+  const onOffline = () => sink.crumb("network", "Device went offline", "warning");
+  d.addEventListener("visibilitychange", onVis);
+  g.addEventListener("online", onOnline);
+  g.addEventListener("offline", onOffline);
+  return () => {
+    d.removeEventListener("visibilitychange", onVis);
+    g.removeEventListener("online", onOnline);
+    g.removeEventListener("offline", onOffline);
+  };
+}
+
+// src/client.ts
+var SDK_NAME = "@debugkit/sdk";
+var SDK_VERSION = "0.3.0";
+var QUEUE_KEY = "@debugkit/queue";
+var MAX_QUEUE = 500;
+var uid = () => {
+  var _a, _b, _c;
+  return ((_c = (_b = (_a = globalThis.crypto) == null ? void 0 : _a.randomUUID) == null ? void 0 : _b.call(_a)) != null ? _c : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 12)}`).replace(/-/g, "");
+};
+var now = () => (/* @__PURE__ */ new Date()).toISOString();
+var DebugClient = class {
+  constructor() {
+    __publicField(this, "opts");
+    __publicField(this, "queue", []);
+    __publicField(this, "crumbs", []);
+    __publicField(this, "session", { id: uid(), startedAt: now() });
+    __publicField(this, "user", { anonymousId: uid() });
+    __publicField(this, "timer");
+    __publicField(this, "flushing");
+    __publicField(this, "backoffUntil", 0);
+    __publicField(this, "failures", 0);
+    __publicField(this, "ready", false);
+    __publicField(this, "handlersInstalled", false);
+    __publicField(this, "auto", { errors: false, network: false, console: false, navigation: false, clicks: false, lifecycle: false, sessions: false });
+    __publicField(this, "restores", []);
+    __publicField(this, "sessionState", { errored: false, crashed: false });
+    __publicField(this, "lastNav");
+    __publicField(this, "limits", /* @__PURE__ */ new Map());
+    /** fetch as it was before instrumentation, so our own uploads are never recorded. */
+    __publicField(this, "rawFetch");
+    /** Set when the ingest rejects 0.2 fields: it predates them, so send what it understands. */
+    __publicField(this, "legacyIngest", false);
+  }
+  init(options) {
+    var _a, _b, _c;
+    if (this.timer) clearInterval(this.timer);
+    this.uninstrument();
+    this.opts = { flushIntervalMs: 5e3, maxBatch: 50, maxBreadcrumbs: 30, ...options };
+    if (!this.opts.context && typeof window !== "undefined") this.opts.context = browserContext();
+    this.auto = resolveAuto(options);
+    this.rawFetch = typeof globalThis.fetch === "function" ? (_a = globalThis.fetch.__raw) != null ? _a : globalThis.fetch : void 0;
+    this.ready = true;
+    void this.restore();
+    if (this.auto.errors && !this.handlersInstalled) this.installGlobalHandlers();
+    this.instrument();
+    if (this.auto.sessions) this.startSession();
+    if (this.opts.flushIntervalMs > 0) {
+      this.timer = setInterval(() => void this.flush(), this.opts.flushIntervalMs);
+      (_c = (_b = this.timer).unref) == null ? void 0 : _c.call(_b);
+    }
+    return this;
+  }
+  /** Which automatic captures are on, after defaults. */
+  get autoCapture() {
+    return this.auto;
+  }
+  /**
+   * Begin a new session: a fresh id and a "started" marker. Called by `init()`, and by the
+   * React Native entry when the app returns after 30 minutes in the background.
+   */
+  startSession() {
+    if (!this.ready) return;
+    void this.flush();
+    this.session = { id: uid(), startedAt: now() };
+    this.sessionState = { errored: false, crashed: false };
+    if (this.auto.sessions) this.push({ type: "session", id: uid(), ts: now(), status: "started" });
+  }
+  /** Record a navigation breadcrumb ("from → to"). Repeated paths are ignored. */
+  navigated(to) {
+    if (!to || to === this.lastNav) return;
+    this.breadcrumb("navigation", this.lastNav ? `${this.lastNav} \u2192 ${to}` : to);
+    this.lastNav = to;
+  }
+  get initialized() {
+    return this.ready;
+  }
+  /** Events waiting to be sent. */
+  get pending() {
+    return this.queue.length;
+  }
+  /** Merge extra context (e.g. after an async device lookup). Applies to events sent from now on. */
+  setContext(patch) {
+    var _a;
+    if (this.opts) this.opts.context = mergeContext((_a = this.opts.context) != null ? _a : {}, patch);
+  }
+  setUser(id) {
+    this.user = { ...this.user, id };
+  }
+  breadcrumb(category, message, data, level = "info") {
+    var _a, _b, _c, _d;
+    const msg = message.slice(0, 500);
+    const last = this.crumbs[this.crumbs.length - 1];
+    if (last && last.category === category && last.message === msg && last.level === level) {
+      last.ts = now();
+      last.data = { ...data, repeated: Number((_b = (_a = last.data) == null ? void 0 : _a.repeated) != null ? _b : 1) + 1 };
+      return;
+    }
+    this.crumbs.push({ ts: now(), category, message: msg, data, level });
+    if (this.crumbs.length > ((_d = (_c = this.opts) == null ? void 0 : _c.maxBreadcrumbs) != null ? _d : 30)) this.crumbs.shift();
+  }
+  /** Log an error. `flow` is the part of the app it belongs to, e.g. "auth.login". */
+  error(err, meta = {}) {
+    this.captureError(normaliseError(err), meta);
+  }
+  /** Log a custom event. Use outcome to let deBug compute failure rates per flow. */
+  event(name, meta = {}) {
+    this.breadcrumb("event", name, meta.props);
+    this.enqueue({ type: "event", id: uid(), ts: now(), name, flow: meta.flow, step: meta.step, tags: meta.tags, outcome: meta.outcome, props: meta.props });
+  }
+  /**
+   * Wraps an async step: logs a success or failure outcome for the flow, plus the error.
+   * Pass `{ captureError: false }` when the error is already reported elsewhere, e.g. a
+   * server function wrapped in withDebug, so it isn't counted twice.
+   */
+  async track(flow, step, fn, opts = {}) {
+    try {
+      const out = await fn();
+      this.event(`${flow}.${step}`, { flow, step, outcome: "success" });
+      return out;
+    } catch (err) {
+      this.event(`${flow}.${step}`, { flow, step, outcome: "failure" });
+      if (opts.captureError !== false) this.error(err, { flow, step });
+      throw err;
+    }
+  }
+  async flush() {
+    if (this.flushing) await this.flushing.catch(() => {
+    });
+    if (this.flushing) return this.flushing;
+    if (!this.ready || this.queue.length === 0 || Date.now() < this.backoffUntil) return;
+    const batch = this.queue.splice(0, this.opts.maxBatch);
+    this.flushing = this.send(batch).then(() => {
+      this.failures = 0;
+    }).catch((err) => {
+      this.queue.unshift(...batch);
+      this.failures++;
+      this.backoffUntil = Date.now() + Math.min(6e4, 1e3 * 2 ** this.failures);
+      this.log("flush failed", err);
+    }).finally(() => {
+      this.flushing = void 0;
+      void this.persist();
+    });
+    return this.flushing;
+  }
+  /** Stop the flush timer, undo automatic instrumentation and send what is queued. */
+  close() {
+    if (this.timer) clearInterval(this.timer);
+    this.uninstrument();
+    return this.flush();
+  }
+  /* ---------------- internals ---------------- */
+  /** @internal Used by the platform entry points for errors that have no thrown value. */
+  captureError(e, meta, request) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    if (!this.ready) return;
+    const handled = (_a = meta.handled) != null ? _a : true;
+    const frames = (_b = e.frames) != null ? _b : parseStack(e.stack);
+    if (!meta.fatal && !this.allowError(`${e.name}|${e.message.slice(0, 120)}|${(_d = (_c = frames[0]) == null ? void 0 : _c.file) != null ? _d : ""}:${(_f = (_e = frames[0]) == null ? void 0 : _e.line) != null ? _f : ""}`)) return;
+    if (this.auto.sessions && (!handled || meta.fatal)) {
+      if (!this.sessionState.errored) {
+        this.sessionState.errored = true;
+        this.push({ type: "session", id: uid(), ts: now(), status: "errored" });
+      }
+      if (meta.fatal && !this.sessionState.crashed) {
+        this.sessionState.crashed = true;
+        this.push({ type: "session", id: uid(), ts: now(), status: "crashed" });
+      }
+    }
+    (meta.fatal ? this.push : this.enqueue).call(this, {
+      type: "error",
+      id: uid(),
+      ts: now(),
+      flow: meta.flow,
+      step: meta.step,
+      tags: meta.tags,
+      severity: (_g = meta.severity) != null ? _g : meta.fatal ? "critical" : void 0,
+      handled,
+      error: { name: e.name, message: e.message, stack: e.stack, frames },
+      breadcrumbs: [...this.crumbs],
+      request
+    });
+  }
+  /** Per-minute limits: one runaway error can't flood the queue, the network or your database. */
+  allowError(signature) {
+    var _a;
+    const max = (_a = this.opts.maxErrorsPerMinute) != null ? _a : 60;
+    const t = Date.now();
+    const hit = (key, cap) => {
+      let l = this.limits.get(key);
+      if (!l || t - l.since > 6e4) this.limits.set(key, l = { n: 0, since: t });
+      return ++l.n <= cap;
+    };
+    if (this.limits.size > 200) this.limits.clear();
+    const ok = hit("*", max) && hit(signature, Math.max(1, Math.ceil(max / 6)));
+    if (!ok) this.log("rate limited", signature);
+    return ok;
+  }
+  sampled() {
+    var _a;
+    const r = (_a = this.opts.sampleRate) != null ? _a : 1;
+    return r >= 1 || Math.random() < r;
+  }
+  enqueue(e) {
+    if (!this.ready || !this.sampled()) return;
+    this.push(e);
+  }
+  /** Queue without sampling (sessions must be complete for crash-free rates to be right). */
+  push(e) {
+    if (!this.ready) return;
+    const out = this.opts.beforeSend ? this.opts.beforeSend(e) : e;
+    if (!out) return;
+    this.queue.push(out);
+    if (this.queue.length > MAX_QUEUE) this.queue.splice(0, this.queue.length - MAX_QUEUE);
+    if (out.type === "error" || this.queue.length >= this.opts.maxBatch) void this.flush();
+    else void this.persist();
+  }
+  buildContext() {
+    var _a, _b, _c, _d, _e;
+    const c = (_a = this.opts.context) != null ? _a : {};
+    return {
+      ...c,
+      app: { ...(_b = c.app) != null ? _b : {}, ...this.opts.app },
+      os: { name: "unknown", ...(_c = c.os) != null ? _c : {} },
+      runtime: { name: "unknown", ...(_d = c.runtime) != null ? _d : {} },
+      device: (_e = c.device) != null ? _e : {}
+    };
+  }
+  async send(events) {
+    var _a, _b;
+    if (this.legacyIngest) events = toLegacy(events);
+    if (!events.length) return;
+    const body = {
+      sdk: { name: SDK_NAME, version: SDK_VERSION },
+      context: this.buildContext(),
+      user: this.user,
+      session: this.session,
+      events
+    };
+    const f = (_b = (_a = this.opts.fetch) != null ? _a : this.rawFetch) != null ? _b : fetch;
+    const json = JSON.stringify(body);
+    const res = await f(this.opts.endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json", "x-debug-key": this.opts.ingestKey },
+      body: json,
+      // Lets the last batch finish when the page is closing. Browsers cap keepalive bodies at 64 KB.
+      ...typeof window !== "undefined" && json.length < 6e4 ? { keepalive: true } : {}
+    });
+    if (res.status >= 400 && res.status < 500 && res.status !== 429) {
+      this.log(`ingest rejected batch (${res.status})`, await res.text().catch(() => ""));
+      if (res.status === 400 && !this.legacyIngest && hasNewFields(events)) {
+        this.legacyIngest = true;
+        return this.send(events);
+      }
+      return;
+    }
+    if (!res.ok) throw new Error(`ingest responded ${res.status}`);
+  }
+  async persist() {
+    var _a;
+    try {
+      await ((_a = this.opts.storage) == null ? void 0 : _a.setItem(QUEUE_KEY, JSON.stringify(this.queue)));
+    } catch {
+    }
+  }
+  async restore() {
+    var _a;
+    try {
+      const raw = await ((_a = this.opts.storage) == null ? void 0 : _a.getItem(QUEUE_KEY));
+      if (raw) this.queue.unshift(...JSON.parse(raw));
+    } catch {
+    }
+  }
+  installGlobalHandlers() {
+    var _a, _b, _c;
+    this.handlersInstalled = true;
+    const g2 = globalThis;
+    if ((_a = g2.ErrorUtils) == null ? void 0 : _a.setGlobalHandler) {
+      const prev = (_c = (_b = g2.ErrorUtils).getGlobalHandler) == null ? void 0 : _c.call(_b);
+      g2.ErrorUtils.setGlobalHandler((err, isFatal) => {
+        this.error(err, { handled: false, fatal: !!isFatal, tags: { source: "global-handler" } });
+        void this.flush();
+        prev == null ? void 0 : prev(err, isFatal);
+      });
+    }
+    if (typeof window !== "undefined" && typeof g2.addEventListener === "function") {
+      g2.addEventListener("error", (ev) => {
+        var _a2;
+        return this.error((_a2 = ev.error) != null ? _a2 : ev.message, { handled: false, tags: { source: "window.onerror" } });
+      });
+      g2.addEventListener("unhandledrejection", (ev) => this.error(ev.reason, { handled: false, tags: { source: "unhandledrejection" } }));
+    }
+  }
+  instrument() {
+    const a = this.auto;
+    const sink = this.sink();
+    const add = (r) => r && this.restores.push(r);
+    if (a.network) {
+      const restoreFetch = instrumentFetch(sink);
+      if (restoreFetch) globalThis.fetch.__raw = this.rawFetch;
+      add(restoreFetch);
+      add(instrumentXhr(sink));
+    }
+    if (a.console) add(instrumentConsole(sink));
+    if (a.navigation) add(instrumentHistory(sink));
+    if (a.clicks) add(instrumentClicks(sink));
+    if (a.lifecycle) add(instrumentWebLifecycle(sink));
+  }
+  uninstrument() {
+    while (this.restores.length) this.restores.pop()();
+  }
+  /** The bridge the instrumentation (./auto, and the platform entry points) reports through. */
+  sink() {
+    return {
+      request: (r) => this.recordRequest(r),
+      crumb: (category, message, level = "info", data) => this.breadcrumb(category, message, data, level),
+      navigated: (to) => this.navigated(to),
+      lifecycle: (state) => {
+        this.breadcrumb("ui", state === "background" ? "App went to the background" : "App came to the foreground");
+        if (state === "background") void this.flush();
+      },
+      ignored: (url) => this.isIgnored(url)
+    };
+  }
+  isIgnored(url) {
+    var _a, _b;
+    if (!this.ready) return true;
+    const ep = this.opts.endpoint.replace(/^https?:/, "");
+    if (url.includes(ep) || /\/symbolicate\b|\/logs(?:\?|$)/.test(url)) return true;
+    return ((_b = (_a = this.opts.network) == null ? void 0 : _a.ignoreUrls) != null ? _b : []).some((p) => typeof p === "string" ? url.includes(p) : p.test(url));
+  }
+  recordRequest(r) {
+    var _a, _b, _c, _d, _e, _f;
+    if (!this.ready) return;
+    const net = (_a = this.opts.network) != null ? _a : {};
+    const url = normaliseUrl(r.url);
+    const ms = Math.round(r.durationMs);
+    const failed = r.status === void 0 ? !r.aborted : ((_b = net.isFailure) != null ? _b : ((s) => s >= 500))(r.status, url);
+    const slow = ms >= ((_c = net.slowMs) != null ? _c : 3e3);
+    const outcome = r.aborted ? "aborted" : r.timedOut ? "timed out" : r.status !== void 0 ? String(r.status) : "failed";
+    this.breadcrumb("network", `${r.method} ${url} \u2192 ${outcome} (${ms}ms)`, { status: (_d = r.status) != null ? _d : null, durationMs: ms }, failed ? "error" : slow ? "warning" : "info");
+    if (!failed) return;
+    const flow = (_f = (_e = net.flows) == null ? void 0 : _e.find(([p]) => typeof p === "string" ? url.includes(p) : p.test(url))) == null ? void 0 : _f[1];
+    const cause = r.error ? normaliseError(r.error) : void 0;
+    const message = r.status !== void 0 ? `${r.method} ${url} responded ${r.status}` : `${r.method} ${url} ${r.timedOut ? "timed out" : "failed"}${cause ? `: ${cause.message}` : ""}`;
+    const frames = parseStack(r.stack).slice(1);
+    this.captureError(
+      { name: r.status !== void 0 ? "HttpError" : "NetworkError", message, stack: r.stack, frames },
+      { flow, handled: true, tags: { source: "network" } },
+      { method: r.method, url, status: r.status, durationMs: ms }
+    );
+  }
+  log(...args) {
+    var _a;
+    if ((_a = this.opts) == null ? void 0 : _a.debug) console.warn("[deBug]", ...args);
+  }
+};
+function normaliseError(err) {
+  if (err instanceof Error) return { name: err.name || "Error", message: err.message, stack: err.stack };
+  if (typeof err === "string") return { name: "Error", message: err };
+  try {
+    return { name: "NonError", message: JSON.stringify(err).slice(0, 2e3) };
+  } catch {
+    return { name: "NonError", message: String(err) };
+  }
+}
+function resolveAuto(o) {
+  var _a;
+  const all = o.autoCapture !== false;
+  const sel = typeof o.autoCapture === "object" ? o.autoCapture : {};
+  const pick = (k, dflt = all) => {
+    var _a2;
+    return (_a2 = sel[k]) != null ? _a2 : dflt;
+  };
+  return {
+    errors: (_a = o.captureGlobalErrors) != null ? _a : pick("errors"),
+    network: pick("network"),
+    console: pick("console"),
+    navigation: pick("navigation"),
+    clicks: pick("clicks"),
+    lifecycle: pick("lifecycle"),
+    sessions: pick("sessions")
+  };
+}
+var hasNewFields = (events) => events.some((e) => e.type === "session" || e.type === "error" && e.request);
+function toLegacy(events) {
+  const out = [];
+  for (const e of events) {
+    if (e.type === "session") continue;
+    if (e.type === "error" && e.request) {
+      const { request: _r, ...rest } = e;
+      out.push(rest);
+    } else out.push(e);
+  }
+  return out;
+}
+
+// src/index.ts
+var deBug = new DebugClient();
+
+exports.DebugClient = DebugClient;
+exports.SDK_NAME = SDK_NAME;
+exports.SDK_VERSION = SDK_VERSION;
+exports.__publicField = __publicField;
+exports.browserContext = browserContext;
+exports.deBug = deBug;
+exports.locale = locale;
+exports.mergeContext = mergeContext;
+exports.normaliseUrl = normaliseUrl;
+exports.parseStack = parseStack;
+exports.timezone = timezone;
+//# sourceMappingURL=chunk-Q33W6RAG.cjs.map
+//# sourceMappingURL=chunk-Q33W6RAG.cjs.map