@edraj/sauron-browser 1.0.0

package/dist/index.js

@@ -0,0 +1,1922 @@
+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);
+
+// src/utils.ts
+var SDK_NAME = "sauron.javascript";
+var SDK_VERSION = "1.0.0";
+function getGlobal() {
+  return globalThis;
+}
+function getCrypto() {
+  const g2 = getGlobal();
+  return g2.crypto;
+}
+function uuidv4() {
+  const c = getCrypto();
+  if (c && typeof c.randomUUID === "function") {
+    return c.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  if (c && typeof c.getRandomValues === "function") {
+    c.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 16; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = [];
+  for (let i = 0; i < 16; i++) hex.push(bytes[i].toString(16).padStart(2, "0"));
+  const s = hex.join("");
+  return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20)}`;
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function safeStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(value, (_key, val) => {
+      if (typeof val === "bigint") return val.toString();
+      if (typeof val === "function") return void 0;
+      if (typeof val === "object" && val !== null) {
+        if (seen.has(val)) return "[Circular]";
+        seen.add(val);
+      }
+      return val;
+    });
+  } catch {
+    return "{}";
+  }
+}
+function byteLength(s) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(s).length;
+  }
+  let len = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 128) len += 1;
+    else if (c < 2048) len += 2;
+    else if (c >= 55296 && c <= 56319) {
+      len += 4;
+      i++;
+    } else len += 3;
+  }
+  return len;
+}
+function computeBackoff(attempt, baseMs = 1e3, capMs = 3e4) {
+  const ceiling = Math.min(capMs, baseMs * Math.pow(2, Math.max(0, attempt)));
+  return Math.round(Math.random() * ceiling);
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function makeLogger(debug) {
+  const noop = () => {
+  };
+  if (!debug || typeof console === "undefined") {
+    return { log: noop, warn: noop };
+  }
+  return {
+    log: (...args) => console.log("[sauron]", ...args),
+    warn: (...args) => console.warn("[sauron]", ...args)
+  };
+}
+
+// src/identity.ts
+var DEVICE_ID_KEY = "sauron.device_id";
+var SESSION_ID_KEY = "sauron.session_id";
+function webStorage(name) {
+  try {
+    const s = globalThis[name];
+    if (!s) return null;
+    const probe = "__sauron_probe__";
+    s.setItem(probe, "1");
+    s.removeItem(probe);
+    return s;
+  } catch {
+    return null;
+  }
+}
+function persistentId(cached, storage, key) {
+  if (cached) return cached;
+  if (storage) {
+    try {
+      const existing = storage.getItem(key);
+      if (existing) return existing;
+    } catch {
+    }
+  }
+  const fresh = uuidv4();
+  if (storage) {
+    try {
+      storage.setItem(key, fresh);
+    } catch {
+    }
+  }
+  return fresh;
+}
+var deviceId = null;
+var sessionId = null;
+function getDeviceId() {
+  deviceId = persistentId(deviceId, webStorage("localStorage"), DEVICE_ID_KEY);
+  return deviceId;
+}
+function getSessionId() {
+  sessionId = persistentId(sessionId, webStorage("sessionStorage"), SESSION_ID_KEY);
+  return sessionId;
+}
+
+// src/context.ts
+function getNavigator() {
+  const g2 = globalThis;
+  return g2.navigator;
+}
+function detectOs(ua) {
+  let m = ua.match(/Windows NT ([\d.]+)/);
+  if (m) return { name: "Windows", version: m[1] };
+  m = ua.match(/iPhone OS (\d+[_\d]*)/) || ua.match(/CPU OS (\d+[_\d]*) like Mac/);
+  if (m) return { name: "iOS", version: m[1].replace(/_/g, ".") };
+  m = ua.match(/Mac OS X (\d+[_\d]*)/);
+  if (m) return { name: "macOS", version: m[1].replace(/_/g, ".") };
+  m = ua.match(/Android ([\d.]+)/);
+  if (m) return { name: "Android", version: m[1] };
+  if (/Linux/.test(ua)) return { name: "Linux", version: null };
+  if (/CrOS/.test(ua)) return { name: "Chrome OS", version: null };
+  return { name: null, version: null };
+}
+function detectRuntime(ua) {
+  let m = ua.match(/Edg(?:e|A|iOS)?\/([\d.]+)/);
+  if (m) return { name: "Edge", version: major(m[1]) };
+  m = ua.match(/OPR\/([\d.]+)/) || ua.match(/Opera\/([\d.]+)/);
+  if (m) return { name: "Opera", version: major(m[1]) };
+  m = ua.match(/Firefox\/([\d.]+)/);
+  if (m) return { name: "Firefox", version: major(m[1]) };
+  m = ua.match(/Chrome\/([\d.]+)/);
+  if (m) return { name: "Chrome", version: major(m[1]) };
+  m = ua.match(/Version\/([\d.]+).*Safari/);
+  if (m) return { name: "Safari", version: major(m[1]) };
+  if (/Safari/.test(ua)) return { name: "Safari", version: null };
+  return { name: null, version: null };
+}
+function detectDevice(nav, ua) {
+  const platform = nav?.userAgentData?.platform ?? nav?.platform ?? "";
+  let family = null;
+  if (/Mac|iPhone|iPad|iPod/.test(platform) || /iPhone|iPad|Macintosh/.test(ua)) {
+    family = "Apple";
+  } else if (/Win/.test(platform) || /Windows/.test(ua)) {
+    family = "Microsoft";
+  } else if (/Android/.test(ua)) {
+    family = "Google";
+  } else if (/Linux/.test(platform) || /Linux/.test(ua)) {
+    family = "Linux";
+  }
+  return { device_id: getDeviceId(), family, model: null, arch: null };
+}
+function major(version) {
+  const dot = version.indexOf(".");
+  return dot === -1 ? version : version.slice(0, dot);
+}
+function appFromRelease(release) {
+  if (!release) return { version: null, build: null };
+  const at = release.lastIndexOf("@");
+  const version = at === -1 ? release : release.slice(at + 1);
+  return { version: version || null, build: null };
+}
+function detectContext(release) {
+  const nav = getNavigator();
+  const ua = nav?.userAgent ?? "";
+  return {
+    device: detectDevice(nav, ua),
+    os: detectOs(ua),
+    app: appFromRelease(release),
+    runtime: detectRuntime(ua)
+  };
+}
+function buildContext(release, user) {
+  return { ...detectContext(release), user };
+}
+
+// src/dsn.ts
+var DsnError = class extends Error {
+  constructor(message) {
+    super(`[sauron] invalid DSN: ${message}`);
+    this.name = "DsnError";
+  }
+};
+function parseDsn(dsn) {
+  if (typeof dsn !== "string" || dsn.length === 0) {
+    throw new DsnError("DSN must be a non-empty string");
+  }
+  let url;
+  try {
+    url = new URL(dsn);
+  } catch {
+    throw new DsnError(`could not parse "${dsn}"`);
+  }
+  const protocol = url.protocol.replace(/:$/, "");
+  if (protocol !== "http" && protocol !== "https") {
+    throw new DsnError(`unsupported protocol "${protocol}"`);
+  }
+  const publicKey = url.username;
+  if (!publicKey) {
+    throw new DsnError('missing public key (the "user" part of the URL)');
+  }
+  if (url.password) {
+    throw new DsnError("DSN must not contain a secret (password component)");
+  }
+  const host = url.host;
+  const hostname = url.hostname;
+  if (!host) {
+    throw new DsnError("missing host");
+  }
+  const projectId = url.pathname.replace(/^\/+/, "").replace(/\/+$/, "");
+  if (!projectId) {
+    throw new DsnError("missing project id (the path segment)");
+  }
+  const base = `${protocol}://${host}/api/${projectId}/envelope`;
+  const beaconUrl = `${base}?k=${encodeURIComponent(publicKey)}`;
+  return {
+    raw: dsn,
+    publicKey,
+    host,
+    hostname,
+    protocol,
+    projectId,
+    envelopeUrl: base,
+    beaconUrl
+  };
+}
+
+// src/envelope.ts
+function buildEnvelope(header, context, items) {
+  return {
+    header,
+    context,
+    items
+  };
+}
+
+// src/integrations/instrument.ts
+var WRAPPED = "__sauron_wrapped__";
+var internalDepth = 0;
+function beginInternal() {
+  internalDepth++;
+}
+function endInternal() {
+  internalDepth = Math.max(0, internalDepth - 1);
+}
+function withInternal(fn) {
+  beginInternal();
+  try {
+    return fn();
+  } finally {
+    endInternal();
+  }
+}
+function isInternal() {
+  return internalDepth > 0;
+}
+var dsnHost = null;
+function setDsnHost(host) {
+  dsnHost = host;
+}
+function isDsnRequest(rawUrl) {
+  if (!dsnHost || !rawUrl) return false;
+  try {
+    const base = globalThis.location?.href;
+    const u = new URL(rawUrl, base);
+    return u.host === dsnHost;
+  } catch {
+    return false;
+  }
+}
+function markWrapped(fn) {
+  try {
+    fn[WRAPPED] = true;
+  } catch {
+  }
+  return fn;
+}
+function isWrapped(fn) {
+  if (fn === null || typeof fn !== "function" && typeof fn !== "object") return false;
+  return fn[WRAPPED] === true;
+}
+var patches = [];
+function registerPatch(name, unpatch) {
+  patches.push({ name, unpatch });
+}
+function unpatchAll() {
+  while (patches.length) {
+    const p = patches.pop();
+    try {
+      p?.unpatch();
+    } catch {
+    }
+  }
+}
+
+// src/integrations/console.ts
+var METHODS = ["log", "info", "warn", "error", "debug"];
+function toLevel(method) {
+  switch (method) {
+    case "warn":
+      return "warning";
+    case "error":
+      return "error";
+    case "debug":
+      return "debug";
+    default:
+      return "info";
+  }
+}
+function argToString(arg) {
+  if (typeof arg === "string") return arg;
+  if (arg instanceof Error) return `${arg.name}: ${arg.message}`;
+  try {
+    return JSON.stringify(arg);
+  } catch {
+    return String(arg);
+  }
+}
+function installConsole() {
+  const consoleObj = globalThis.console;
+  if (!consoleObj) return;
+  const c = consoleObj;
+  for (const method of METHODS) {
+    const original = c[method];
+    if (typeof original !== "function" || isWrapped(original)) continue;
+    const originalFn = original;
+    const wrapped = markWrapped(function sauronConsole(...args) {
+      if (!isInternal()) {
+        withInternal(() => {
+          try {
+            addBreadcrumb({
+              type: "default",
+              category: "console",
+              level: toLevel(method),
+              message: args.map(argToString).join(" ").slice(0, 512),
+              data: { arguments: args.length }
+            });
+          } catch {
+          }
+        });
+      }
+      return originalFn.apply(this, args);
+    });
+    c[method] = wrapped;
+    registerPatch(`console.${method}`, () => {
+      c[method] = originalFn;
+    });
+  }
+}
+
+// src/integrations/dom.ts
+function domSelector(el) {
+  try {
+    const node = el;
+    if (!node || typeof node.tagName !== "string") return null;
+    let selector = node.tagName.toLowerCase();
+    if (node.id && typeof node.id === "string") {
+      selector += `#${node.id}`;
+    }
+    if (typeof node.className === "string" && node.className.trim()) {
+      const classes = node.className.trim().split(/\s+/).slice(0, 3);
+      if (classes.length) selector += `.${classes.join(".")}`;
+    }
+    return selector;
+  } catch {
+    return null;
+  }
+}
+function installDom() {
+  const doc = globalThis.document;
+  if (!doc || typeof doc.addEventListener !== "function") return;
+  const handler = (event) => {
+    if (isInternal()) return;
+    const selector = domSelector(event.target);
+    if (!selector) return;
+    withInternal(() => {
+      addBreadcrumb({
+        type: "default",
+        category: "ui.click",
+        level: "info",
+        message: selector,
+        data: null
+      });
+    });
+  };
+  const options = { capture: true, passive: true };
+  doc.addEventListener("click", handler, options);
+  registerPatch("dom.click", () => {
+    try {
+      doc.removeEventListener("click", handler, options);
+    } catch {
+    }
+  });
+}
+
+// src/integrations/fetch.ts
+function resolveUrl(input) {
+  if (typeof input === "string") return input;
+  if (input && typeof input === "object") {
+    const withUrl = input;
+    if (typeof withUrl.url === "string") return withUrl.url;
+    if (typeof withUrl.href === "string") return withUrl.href;
+  }
+  return String(input);
+}
+function resolveMethod(input, init3) {
+  const fromInit = init3?.method;
+  const fromReq = input?.method;
+  return String(fromInit ?? fromReq ?? "GET").toUpperCase();
+}
+function addFetchBreadcrumb(method, url, status, startedAt) {
+  withInternal(() => {
+    addBreadcrumb({
+      type: "default",
+      category: "fetch",
+      level: status !== null && status >= 400 ? "warning" : "info",
+      message: `${method} ${url}`,
+      timestamp: startedAt,
+      data: { method, url, status_code: status }
+    });
+  });
+}
+function installFetch() {
+  const g2 = globalThis;
+  const original = g2.fetch;
+  if (typeof original !== "function" || isWrapped(original)) return;
+  const wrapped = markWrapped(function sauronFetch(input, init3) {
+    const url = resolveUrl(input);
+    const shouldRecord = !isInternal() && !isDsnRequest(url);
+    const method = resolveMethod(input, init3);
+    const startedAt = nowIso();
+    const promise = original.call(this, input, init3);
+    if (shouldRecord) {
+      promise.then(
+        (res) => addFetchBreadcrumb(method, url, res?.status ?? null, startedAt),
+        () => addFetchBreadcrumb(method, url, null, startedAt)
+      );
+    }
+    return promise;
+  });
+  g2.fetch = wrapped;
+  registerPatch("fetch", () => {
+    g2.fetch = original;
+  });
+}
+
+// src/screen.ts
+var currentScreen = null;
+function getScreen() {
+  return currentScreen;
+}
+function setScreenState(name) {
+  if (name === currentScreen) return false;
+  currentScreen = name;
+  return true;
+}
+function resetScreen() {
+  currentScreen = null;
+}
+
+// src/stacktrace/parse.ts
+var MAX_FRAMES = 50;
+var V8_RE = /^\s*at (?:(.+?) )?\(?((?:[a-z][\w.+-]*:\/\/)?[^\s()]+?):(\d+):(\d+)\)?\s*$/i;
+var GECKO_RE = /^\s*(?:([^@]*?)@)?((?:[a-z][\w.+-]*:\/\/)?[^@\s]+?):(\d+):(\d+)\s*$/i;
+function cleanFunction(fn) {
+  if (!fn) return null;
+  let name = fn.trim();
+  name = name.replace(/^async\s+/, "").replace(/^new\s+/, "new ");
+  name = name.replace(/\s+\[as .+\]$/, "");
+  if (name === "<anonymous>" || name === "") return null;
+  return name;
+}
+function isInAppFrame(filename) {
+  if (!filename) return false;
+  if (filename === "<anonymous>" || filename.startsWith("node:") || filename.startsWith("internal/")) {
+    return false;
+  }
+  const hasProtocol = /^[a-z][\w.+-]*:\/\//i.test(filename);
+  if (!hasProtocol) {
+    return true;
+  }
+  const origin = getOrigin();
+  if (origin && filename.startsWith(origin)) {
+    return true;
+  }
+  return false;
+}
+function getOrigin() {
+  const loc = globalThis.location;
+  return loc?.origin ?? "";
+}
+function parseLine(line) {
+  let m = V8_RE.exec(line);
+  if (!m) m = GECKO_RE.exec(line);
+  if (!m) return null;
+  const filename = m[2] || null;
+  const lineno = m[3] ? parseInt(m[3], 10) : null;
+  const colno = m[4] ? parseInt(m[4], 10) : null;
+  return {
+    function: cleanFunction(m[1]),
+    filename,
+    lineno: Number.isNaN(lineno) ? null : lineno,
+    colno: Number.isNaN(colno) ? null : colno,
+    in_app: isInAppFrame(filename)
+  };
+}
+function parseStackString(stack) {
+  if (!stack) return [];
+  const frames = [];
+  const lines = stack.split("\n");
+  for (const raw of lines) {
+    const line = raw.replace(/\r$/, "");
+    if (!line.trim()) continue;
+    const frame = parseLine(line);
+    if (frame) {
+      frames.push(frame);
+      if (frames.length >= MAX_FRAMES) break;
+    }
+  }
+  frames.reverse();
+  return frames;
+}
+function parseError(err) {
+  if (err && typeof err === "object" && "stack" in err) {
+    const stack = err.stack;
+    if (typeof stack === "string") return parseStackString(stack);
+  }
+  return [];
+}
+
+// src/api/capture.ts
+var DEFAULT_MECHANISM = { type: "generic", handled: true };
+function attachCallMeta(item, hint) {
+  if (hint?.tags && Object.keys(hint.tags).length > 0) item.tags = { ...hint.tags };
+  if (hint?.contexts && Object.keys(hint.contexts).length > 0) item.contexts = { ...hint.contexts };
+  if (hint?.extra && Object.keys(hint.extra).length > 0) item.extra = { ...hint.extra };
+}
+function isErrorLike(err) {
+  return err instanceof Error || typeof err === "object" && err !== null && "name" in err && "message" in err && typeof err.message === "string";
+}
+function extractError(err) {
+  if (isErrorLike(err)) {
+    const e = err;
+    return {
+      type: e.name || "Error",
+      value: e.message ?? "",
+      stacktrace: parseError(e)
+    };
+  }
+  if (typeof err === "string") {
+    return { type: "Error", value: err, stacktrace: [] };
+  }
+  if (typeof err === "object" && err !== null) {
+    const ctor = err.constructor;
+    return {
+      type: ctor?.name ?? "Object",
+      value: safeStringify(err),
+      stacktrace: []
+    };
+  }
+  return { type: typeof err, value: String(err), stacktrace: [] };
+}
+function buildErrorItem(err, breadcrumbs, hint) {
+  const extracted = extractError(err);
+  const mechanism = hint?.mechanism ?? DEFAULT_MECHANISM;
+  const level = hint?.level ?? "error";
+  const fingerprint = hint?.fingerprint ?? null;
+  const exception = {
+    type: extracted.type,
+    value: extracted.value,
+    mechanism,
+    stacktrace: extracted.stacktrace
+  };
+  const item = {
+    type: "error",
+    timestamp: nowIso(),
+    level,
+    exception,
+    breadcrumbs,
+    fingerprint,
+    session_id: getSessionId(),
+    screen: hint?.screen ?? getScreen()
+  };
+  attachCallMeta(item, hint);
+  return item;
+}
+function captureException(err, hint) {
+  const client = getClient();
+  if (!client) return;
+  const breadcrumbs = client.getScope().getBreadcrumbs();
+  const fullHint = { ...hint, originalException: err };
+  const item = buildErrorItem(err, breadcrumbs, fullHint);
+  client.captureItem(item, fullHint);
+}
+function captureMessage(message, level = "info", hint) {
+  const client = getClient();
+  if (!client) return;
+  const breadcrumbs = client.getScope().getBreadcrumbs();
+  const item = {
+    type: "error",
+    timestamp: nowIso(),
+    level,
+    exception: {
+      type: null,
+      value: message,
+      mechanism: { type: "message", handled: true },
+      stacktrace: []
+    },
+    breadcrumbs,
+    fingerprint: hint?.fingerprint ?? null,
+    session_id: getSessionId(),
+    screen: getScreen()
+  };
+  attachCallMeta(item, hint);
+  client.captureItem(item, hint);
+}
+
+// src/integrations/globalHandlers.ts
+function installGlobalHandlers() {
+  const win = globalThis;
+  installOnError(win);
+  installOnUnhandledRejection(win);
+}
+function installOnError(win) {
+  const previous = win.onerror;
+  if (isWrapped(previous)) return;
+  const handler = markWrapped(function sauronOnError(message, source, lineno, colno, error) {
+    if (getClient()) {
+      const err = error ?? syntheticError(message, source, lineno, colno);
+      captureException(err, { mechanism: { type: "onerror", handled: false }, level: "error" });
+    }
+    if (typeof previous === "function") {
+      return Boolean(
+        previous.call(this, message, source, lineno, colno, error)
+      );
+    }
+    return false;
+  });
+  win.onerror = handler;
+  registerPatch("onerror", () => {
+    win.onerror = previous ?? null;
+  });
+}
+function installOnUnhandledRejection(win) {
+  const previous = win.onunhandledrejection;
+  if (isWrapped(previous)) return;
+  const handler = markWrapped(function sauronOnRejection(event) {
+    if (getClient()) {
+      const reason = event && typeof event === "object" && "reason" in event ? event.reason : event;
+      captureException(reason, {
+        mechanism: { type: "onunhandledrejection", handled: false },
+        level: "error"
+      });
+    }
+    if (typeof previous === "function") {
+      return previous.call(this, event);
+    }
+    return void 0;
+  });
+  win.onunhandledrejection = handler;
+  registerPatch("onunhandledrejection", () => {
+    win.onunhandledrejection = previous ?? null;
+  });
+}
+function syntheticError(message, source, lineno, colno) {
+  const msg = typeof message === "string" ? message : "Unknown error";
+  const err = new Error(msg);
+  if (source) {
+    err.stack = `Error: ${msg}
+    at ${source}:${lineno ?? 0}:${colno ?? 0}`;
+  }
+  return err;
+}
+
+// src/integrations/history.ts
+var navHandler = null;
+function onNavigation(cb) {
+  navHandler = cb;
+}
+function toPath(url, base) {
+  if (url === null || url === void 0) return url;
+  try {
+    const parsed = new URL(url, base);
+    return parsed.pathname + parsed.search + parsed.hash;
+  } catch {
+    return url;
+  }
+}
+function installHistory() {
+  const g2 = globalThis;
+  const hist = g2.history;
+  const loc = g2.location;
+  if (!hist) return;
+  let lastPath = toPath(loc?.href ?? null, loc?.href);
+  const emit = (toHref) => {
+    const to = toPath(toHref, loc?.href);
+    const from = lastPath;
+    lastPath = to;
+    if (from === to) return;
+    withInternal(() => addNavigationBreadcrumb(from, to));
+    if (to && navHandler) {
+      try {
+        navHandler(to);
+      } catch {
+      }
+    }
+  };
+  const wrap = (name) => {
+    const original = hist[name];
+    if (typeof original !== "function" || isWrapped(original)) return;
+    hist[name] = markWrapped(function sauronHistory(...args) {
+      const result = original.apply(this, args);
+      if (!isInternal()) {
+        const urlArg = args[2];
+        emit(urlArg != null ? String(urlArg) : loc?.href ?? null);
+      }
+      return result;
+    });
+    registerPatch(`history.${name}`, () => {
+      hist[name] = original;
+    });
+  };
+  wrap("pushState");
+  wrap("replaceState");
+  if (typeof g2.addEventListener === "function") {
+    const onPopState = () => {
+      if (!isInternal()) emit(loc?.href ?? null);
+    };
+    g2.addEventListener("popstate", onPopState);
+    registerPatch("popstate", () => {
+      g2.removeEventListener?.("popstate", onPopState);
+    });
+  }
+}
+
+// src/scope.ts
+function emptyUser() {
+  return { id: null, email: null, traits: {} };
+}
+function mergeMeta(base, override) {
+  return override ? { ...base, ...override } : { ...base };
+}
+var Scope = class {
+  constructor(maxBreadcrumbs = 50) {
+    __publicField(this, "user", null);
+    __publicField(this, "breadcrumbs", []);
+    __publicField(this, "maxBreadcrumbs");
+    __publicField(this, "tags", {});
+    __publicField(this, "contexts", {});
+    __publicField(this, "extra", {});
+    this.maxBreadcrumbs = Math.max(0, maxBreadcrumbs);
+  }
+  setMaxBreadcrumbs(max) {
+    this.maxBreadcrumbs = Math.max(0, max);
+    this.trim();
+  }
+  setUser(user) {
+    if (user === null) {
+      this.user = null;
+      return;
+    }
+    this.user = {
+      id: user.id ?? null,
+      email: user.email ?? null,
+      traits: user.traits ?? {}
+    };
+  }
+  /** The user context for an envelope. Never null — defaults to an empty user. */
+  getUser() {
+    return this.user ? { ...this.user, traits: { ...this.user.traits } } : emptyUser();
+  }
+  /** True when an identifiable user has been set. */
+  hasUser() {
+    return this.user !== null;
+  }
+  setTag(key, value) {
+    this.tags[key] = value;
+  }
+  /** Merge a batch of tags into the scope (last-write-wins per key). */
+  setTags(tags) {
+    Object.assign(this.tags, tags);
+  }
+  /** Set (replace) a named context block on the scope. */
+  setContext(name, block) {
+    this.contexts[name] = block;
+  }
+  /** Set a single freeform extra value on the scope. */
+  setExtra(key, value) {
+    this.extra[key] = value;
+  }
+  addBreadcrumb(breadcrumb) {
+    if (this.maxBreadcrumbs <= 0) return;
+    this.breadcrumbs.push(breadcrumb);
+    this.trim();
+  }
+  /** A defensive copy of the current breadcrumb trail. */
+  getBreadcrumbs() {
+    return this.breadcrumbs.slice();
+  }
+  clearBreadcrumbs() {
+    this.breadcrumbs = [];
+  }
+  trim() {
+    const overflow = this.breadcrumbs.length - this.maxBreadcrumbs;
+    if (overflow > 0) {
+      this.breadcrumbs.splice(0, overflow);
+    }
+  }
+};
+
+// src/api/product.ts
+function track(name, properties = {}, options = {}) {
+  const client = getClient();
+  if (!client) return;
+  const scope = client.getScope();
+  const item = {
+    type: "event",
+    name,
+    distinct_id: client.getDistinctId(),
+    session_id: getSessionId(),
+    screen: options.screen ?? getScreen(),
+    timestamp: nowIso(),
+    properties: properties ?? {}
+  };
+  const tags = mergeMeta(scope.tags, options.tags);
+  if (Object.keys(tags).length > 0) item.tags = tags;
+  const contexts = mergeMeta(scope.contexts, options.contexts);
+  if (Object.keys(contexts).length > 0) item.contexts = contexts;
+  const extra = mergeMeta(scope.extra, options.extra);
+  if (Object.keys(extra).length > 0) item.extra = extra;
+  client.captureItem(item);
+}
+function setScreen(name) {
+  if (!setScreenState(name)) return;
+  track("$screen", { screen: name });
+}
+function identify(id, traits = {}) {
+  const client = getClient();
+  if (!client) return;
+  const anonymousId = client.getAnonymousId();
+  client.getScope().setUser({ id, traits });
+  const item = {
+    type: "identify",
+    distinct_id: id,
+    anonymous_id: anonymousId,
+    traits: traits ?? {}
+  };
+  client.captureItem(item);
+}
+var TRANSACTION_OPS = [
+  "navigation",
+  "http",
+  "resource",
+  "screen_load",
+  "custom"
+];
+function normalizeOp(op) {
+  return op && TRANSACTION_OPS.includes(op) ? op : "custom";
+}
+function buildTransactionItem(input, distinctId, sessionId2) {
+  return {
+    type: "transaction",
+    name: input.name,
+    op: normalizeOp(input.op),
+    duration_ms: input.durationMs,
+    status: input.status ?? null,
+    http_method: input.httpMethod ?? null,
+    http_status: input.httpStatus ?? null,
+    url: input.url ?? null,
+    distinct_id: distinctId,
+    session_id: sessionId2,
+    timestamp: nowIso()
+  };
+}
+function trackTransaction(input) {
+  const client = getClient();
+  if (!client) return;
+  const item = buildTransactionItem(input, client.getDistinctId(), getSessionId());
+  client.captureItem(item);
+}
+
+// src/integrations/performance.ts
+var PERF_FETCH = "__sauron_perf_fetch__";
+var PERF_HISTORY = "__sauron_perf_history__";
+function g() {
+  return globalThis;
+}
+function mark(fn, key) {
+  fn[key] = true;
+}
+function isMarked(fn, key) {
+  return typeof fn === "function" && fn[key] === true;
+}
+function clock() {
+  const perf = g().performance;
+  if (perf && typeof perf.now === "function") return () => perf.now();
+  return () => Date.now();
+}
+function resolveUrl2(input) {
+  if (typeof input === "string") return input;
+  if (input && typeof input === "object") {
+    const withUrl = input;
+    if (typeof withUrl.url === "string") return withUrl.url;
+    if (typeof withUrl.href === "string") return withUrl.href;
+  }
+  return String(input);
+}
+function resolveMethod2(input, init3) {
+  const fromInit = init3?.method;
+  const fromReq = input?.method;
+  return String(fromInit ?? fromReq ?? "GET").toUpperCase();
+}
+function pathOf(url) {
+  if (!url) return "/";
+  try {
+    const base = g().location?.href;
+    return new URL(url, base).pathname;
+  } catch {
+    return url;
+  }
+}
+function navigationDuration(perf) {
+  try {
+    const entries = perf.getEntriesByType?.("navigation");
+    if (entries && entries.length > 0) {
+      const d = entries[0].duration;
+      if (typeof d === "number" && d > 0) return d;
+    }
+  } catch {
+  }
+  const timing = perf.timing;
+  if (timing && timing.loadEventEnd && timing.navigationStart) {
+    const d = timing.loadEventEnd - timing.navigationStart;
+    if (d > 0) return d;
+  }
+  return null;
+}
+function installNavigationTiming() {
+  const perf = g().performance;
+  if (!perf) return;
+  const capture = () => {
+    try {
+      const durationMs = navigationDuration(perf);
+      if (durationMs === null) return;
+      trackTransaction({ name: pathOf(g().location?.pathname), op: "navigation", durationMs });
+    } catch {
+    }
+  };
+  const doc = g().document;
+  if (doc && doc.readyState === "complete") {
+    capture();
+  } else if (typeof g().addEventListener === "function") {
+    const onLoad = () => {
+      capture();
+      g().removeEventListener?.("load", onLoad);
+    };
+    g().addEventListener?.("load", onLoad);
+    registerPatch("perf.load", () => g().removeEventListener?.("load", onLoad));
+  } else {
+    capture();
+  }
+}
+function emitHttp(method, url, start, end, status, ok) {
+  try {
+    trackTransaction({
+      name: `${method} ${pathOf(url)}`,
+      op: "http",
+      durationMs: Math.max(0, end - start),
+      status: ok ? "ok" : "error",
+      httpMethod: method,
+      httpStatus: status ?? void 0,
+      url
+    });
+  } catch {
+  }
+}
+function installFetchTiming() {
+  const original = g().fetch;
+  if (typeof original !== "function") return;
+  if (isMarked(original, PERF_FETCH)) return;
+  const now = clock();
+  const wrapped = function sauronPerfFetch(input, init3) {
+    let url = "";
+    let method = "GET";
+    let record = false;
+    try {
+      url = resolveUrl2(input);
+      method = resolveMethod2(input, init3);
+      record = !isInternal() && !isDsnRequest(url);
+    } catch {
+      record = false;
+    }
+    const start = record ? now() : 0;
+    const promise = original.call(this, input, init3);
+    if (record) {
+      promise.then(
+        (res) => emitHttp(method, url, start, now(), res?.status ?? null, res?.ok ?? false),
+        () => emitHttp(method, url, start, now(), null, false)
+      );
+    }
+    return promise;
+  };
+  mark(wrapped, PERF_FETCH);
+  g().fetch = wrapped;
+  registerPatch("perf.fetch", () => {
+    g().fetch = original;
+  });
+}
+function installHistoryTiming() {
+  const hist = g().history;
+  if (!hist) return;
+  const now = clock();
+  const emit = () => {
+    try {
+      const path = pathOf(g().location?.pathname);
+      const start = now();
+      const finish = () => {
+        try {
+          trackTransaction({ name: path, op: "navigation", durationMs: Math.max(0, now() - start) });
+        } catch {
+        }
+      };
+      const raf = g().requestAnimationFrame;
+      if (typeof raf === "function") raf(finish);
+      else finish();
+    } catch {
+    }
+  };
+  const wrap = (name) => {
+    const original = hist[name];
+    if (typeof original !== "function") return;
+    if (isMarked(original, PERF_HISTORY)) return;
+    const patched = function sauronPerfHistory(...args) {
+      const result = original.apply(this, args);
+      if (!isInternal()) emit();
+      return result;
+    };
+    mark(patched, PERF_HISTORY);
+    hist[name] = patched;
+    registerPatch(`perf.history.${name}`, () => {
+      hist[name] = original;
+    });
+  };
+  wrap("pushState");
+  wrap("replaceState");
+  if (typeof g().addEventListener === "function") {
+    const onPopState = () => {
+      if (!isInternal()) emit();
+    };
+    g().addEventListener?.("popstate", onPopState);
+    registerPatch("perf.popstate", () => g().removeEventListener?.("popstate", onPopState));
+  }
+}
+function installPerformance() {
+  if (typeof g().document === "undefined") return;
+  installNavigationTiming();
+  installFetchTiming();
+  installHistoryTiming();
+}
+
+// src/integrations/xhr.ts
+function addXhrBreadcrumb(meta, status) {
+  withInternal(() => {
+    addBreadcrumb({
+      type: "default",
+      category: "xhr",
+      level: status >= 400 ? "warning" : "info",
+      message: `${meta.method} ${meta.url}`,
+      timestamp: meta.startedAt,
+      data: { method: meta.method, url: meta.url, status_code: status || null }
+    });
+  });
+}
+function installXhr() {
+  const XHR = globalThis.XMLHttpRequest;
+  if (typeof XHR !== "function" || !XHR.prototype) return;
+  const proto = XHR.prototype;
+  const originalOpen = proto.open;
+  const originalSend = proto.send;
+  if (isWrapped(originalOpen) || isWrapped(originalSend)) return;
+  proto.open = markWrapped(function sauronXhrOpen(method, url, ...rest) {
+    this.__sauron_xhr__ = {
+      method: String(method ?? "GET").toUpperCase(),
+      url: String(url),
+      startedAt: nowIso()
+    };
+    return originalOpen.apply(this, [method, url, ...rest]);
+  });
+  proto.send = markWrapped(function sauronXhrSend(...args) {
+    const meta = this.__sauron_xhr__;
+    if (meta && !isInternal() && !isDsnRequest(meta.url)) {
+      const onLoadEnd = () => {
+        try {
+          addXhrBreadcrumb(meta, this.status);
+        } catch {
+        } finally {
+          try {
+            this.removeEventListener("loadend", onLoadEnd);
+          } catch {
+          }
+        }
+      };
+      try {
+        this.addEventListener("loadend", onLoadEnd);
+      } catch {
+      }
+    }
+    return originalSend.apply(this, args);
+  });
+  registerPatch("xhr", () => {
+    proto.open = originalOpen;
+    proto.send = originalSend;
+  });
+}
+
+// src/transport/beacon.ts
+function installBeacon(transport) {
+  const win = globalThis;
+  const doc = globalThis.document;
+  const flush2 = () => {
+    try {
+      transport.flushToBeacon();
+    } catch {
+    }
+  };
+  const onVisibility = () => {
+    if (doc && doc.visibilityState === "hidden") flush2();
+  };
+  if (doc && typeof doc.addEventListener === "function") {
+    doc.addEventListener("visibilitychange", onVisibility);
+  }
+  if (typeof win.addEventListener === "function") {
+    win.addEventListener("pagehide", flush2);
+  }
+  return () => {
+    if (doc && typeof doc.removeEventListener === "function") {
+      doc.removeEventListener("visibilitychange", onVisibility);
+    }
+    if (typeof win.removeEventListener === "function") {
+      win.removeEventListener("pagehide", flush2);
+    }
+  };
+}
+
+// src/transport/compress.ts
+var MIN_COMPRESS_BYTES = 1024;
+function getCompressionStream() {
+  const g2 = globalThis;
+  return typeof g2.CompressionStream === "function" ? g2.CompressionStream : void 0;
+}
+async function gzipViaStream(bytes, CS) {
+  const cs = new CS("gzip");
+  const writer = cs.writable.getWriter();
+  void writer.write(bytes);
+  void writer.close();
+  const reader = cs.readable.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) {
+      chunks.push(value);
+      total += value.length;
+    }
+  }
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+async function maybeCompress(json) {
+  const raw = new TextEncoder().encode(json);
+  if (raw.length < MIN_COMPRESS_BYTES) {
+    return { body: json, encoding: null };
+  }
+  const CS = getCompressionStream();
+  if (CS) {
+    try {
+      const gz = await gzipViaStream(raw, CS);
+      return { body: gz, encoding: "gzip" };
+    } catch {
+    }
+  }
+  try {
+    const { gzipSync } = await import('fflate');
+    return { body: gzipSync(raw), encoding: "gzip" };
+  } catch {
+    return { body: json, encoding: null };
+  }
+}
+
+// src/transport/queue.ts
+var QUEUE_KEY = "sauron:queue:v1";
+function defaultStorage() {
+  try {
+    const ls = globalThis.localStorage;
+    if (!ls) return null;
+    const probe = "__sauron_probe__";
+    ls.setItem(probe, "1");
+    ls.removeItem(probe);
+    return ls;
+  } catch {
+    return null;
+  }
+}
+var OfflineQueue = class {
+  constructor(maxBytes, storage, key = QUEUE_KEY) {
+    __publicField(this, "maxBytes");
+    __publicField(this, "storage");
+    __publicField(this, "key");
+    this.maxBytes = Math.max(0, maxBytes);
+    this.storage = storage;
+    this.key = key;
+  }
+  /** True when a real backing store is available. */
+  get available() {
+    return this.storage !== null;
+  }
+  read() {
+    if (!this.storage) return [];
+    try {
+      const raw = this.storage.getItem(this.key);
+      if (!raw) return [];
+      const parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed)) return [];
+      return parsed.filter((x) => typeof x === "string");
+    } catch {
+      return [];
+    }
+  }
+  write(entries) {
+    if (!this.storage) return;
+    try {
+      if (entries.length === 0) {
+        this.storage.removeItem(this.key);
+      } else {
+        this.storage.setItem(this.key, JSON.stringify(entries));
+      }
+    } catch {
+    }
+  }
+  /** Drop oldest entries until the total fits under `maxBytes`. Keeps >= 1. */
+  evict(entries) {
+    let total = 0;
+    for (const e of entries) total += byteLength(e);
+    while (entries.length > 1 && total > this.maxBytes) {
+      const removed = entries.shift();
+      if (removed === void 0) break;
+      total -= byteLength(removed);
+    }
+  }
+  /** Append a payload to the tail (newest), evicting from the head if needed. */
+  enqueue(payload) {
+    if (!this.storage) return;
+    const entries = this.read();
+    entries.push(payload);
+    this.evict(entries);
+    this.write(entries);
+  }
+  /** Remove and return every entry, oldest first. */
+  drain() {
+    const entries = this.read();
+    if (entries.length) this.write([]);
+    return entries;
+  }
+  /** Non-destructive read of the current entries, oldest first. */
+  peek() {
+    return this.read();
+  }
+  /** Number of queued entries. */
+  size() {
+    return this.read().length;
+  }
+  /** Total UTF-8 byte size of the queue. */
+  byteSize() {
+    let total = 0;
+    for (const e of this.read()) total += byteLength(e);
+    return total;
+  }
+  clear() {
+    this.write([]);
+  }
+};
+
+// src/transport/transport.ts
+var BEACON_MAX_BYTES = 64 * 1024;
+var MAX_ITEMS_PER_ENVELOPE = 1e3;
+var MAX_RETRIES = 5;
+var RETRY_AFTER_CAP_MS = 3e4;
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}
+function parseRetryAfter(header) {
+  if (!header) return 1e3;
+  const seconds = Number(header);
+  if (!Number.isNaN(seconds)) {
+    return Math.min(RETRY_AFTER_CAP_MS, Math.max(0, seconds * 1e3));
+  }
+  const date = Date.parse(header);
+  if (!Number.isNaN(date)) {
+    return Math.min(RETRY_AFTER_CAP_MS, Math.max(0, date - Date.now()));
+  }
+  return 1e3;
+}
+function classifyStatus(status, retryAfter) {
+  if (status === 200 || status === 202) return { action: "drop" };
+  if (status === 400) return { action: "drop" };
+  if (status === 401 || status === 403) return { action: "disable" };
+  if (status === 408) return { action: "retry_backoff" };
+  if (status === 413) return { action: "split" };
+  if (status === 429) return { action: "retry_after", retryAfterMs: parseRetryAfter(retryAfter) };
+  if (status >= 500) return { action: "retry_backoff" };
+  if (status >= 400) return { action: "drop" };
+  return { action: "drop" };
+}
+var Transport = class {
+  constructor(config) {
+    __publicField(this, "dsn");
+    __publicField(this, "makeEnvelope");
+    __publicField(this, "fetchImpl");
+    __publicField(this, "logger");
+    __publicField(this, "onDisable");
+    __publicField(this, "flushIntervalMs");
+    __publicField(this, "maxBatch");
+    __publicField(this, "offline");
+    __publicField(this, "pending", []);
+    __publicField(this, "timer", null);
+    __publicField(this, "onlineHandler", null);
+    __publicField(this, "disabled", false);
+    this.dsn = config.dsn;
+    this.makeEnvelope = config.makeEnvelope;
+    this.fetchImpl = config.fetchImpl;
+    this.logger = config.logger;
+    this.onDisable = config.onDisable;
+    this.flushIntervalMs = config.options.flushIntervalMs;
+    this.maxBatch = Math.min(
+      MAX_ITEMS_PER_ENVELOPE,
+      Math.max(1, config.options.maxBatch)
+    );
+    this.offline = new OfflineQueue(config.options.maxQueueBytes, defaultStorage());
+  }
+  /** Begin periodic flushing and listen for connectivity restoration. */
+  start() {
+    if (this.timer === null && this.flushIntervalMs > 0) {
+      this.timer = setInterval(() => {
+        void this.flush();
+      }, this.flushIntervalMs);
+      this.timer.unref?.();
+    }
+    const g2 = globalThis;
+    if (typeof g2.addEventListener === "function" && !this.onlineHandler) {
+      this.onlineHandler = () => {
+        void this.drainOfflineQueue();
+      };
+      g2.addEventListener("online", this.onlineHandler);
+    }
+  }
+  /** Stop timers and listeners (does not flush). */
+  stop() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    const g2 = globalThis;
+    if (this.onlineHandler && typeof g2.removeEventListener === "function") {
+      g2.removeEventListener("online", this.onlineHandler);
+      this.onlineHandler = null;
+    }
+  }
+  /** Permanently disable the transport (401/403). Drops pending work. */
+  disable() {
+    this.disabled = true;
+    this.pending = [];
+    this.stop();
+  }
+  /** Queue an item for the next batch; flush eagerly once the batch is full. */
+  send(item) {
+    if (this.disabled) return;
+    this.pending.push(item);
+    if (this.pending.length >= this.maxBatch) {
+      void this.flush();
+    }
+  }
+  /**
+   * Flush all pending items (plus a drain of the offline queue). Resolves to
+   * `true` on completion, or `false` if `timeoutMs` elapsed first.
+   */
+  async flush(timeoutMs) {
+    if (this.disabled) return true;
+    const items = this.pending.splice(0, this.pending.length);
+    const work = (async () => {
+      await this.drainOfflineQueue();
+      for (let i = 0; i < items.length; i += this.maxBatch) {
+        await this.deliver(items.slice(i, i + this.maxBatch));
+      }
+      return true;
+    })();
+    if (typeof timeoutMs === "number" && timeoutMs >= 0) {
+      return Promise.race([work, delay(timeoutMs).then(() => false)]);
+    }
+    return work;
+  }
+  /** Send an already-serialized batch, applying the retry/backoff policy. */
+  async deliver(items, attempt = 0) {
+    if (this.disabled || items.length === 0) return;
+    const json = safeStringify(this.makeEnvelope(items));
+    let outcome;
+    try {
+      outcome = await this.post(json);
+    } catch {
+      outcome = { action: "retry_backoff" };
+    }
+    switch (outcome.action) {
+      case "drop":
+        return;
+      case "disable":
+        this.logger.warn("server rejected credentials; disabling client");
+        this.onDisable();
+        return;
+      case "split": {
+        if (items.length <= 1) {
+          this.logger.warn("single item too large (413); parking offline");
+          this.offline.enqueue(json);
+          return;
+        }
+        const mid = Math.ceil(items.length / 2);
+        await this.deliver(items.slice(0, mid), attempt);
+        await this.deliver(items.slice(mid), attempt);
+        return;
+      }
+      case "retry_after":
+      case "retry_backoff": {
+        if (attempt >= MAX_RETRIES) {
+          this.offline.enqueue(json);
+          return;
+        }
+        const wait = outcome.action === "retry_after" ? outcome.retryAfterMs ?? 1e3 : computeBackoff(attempt);
+        await delay(wait);
+        return this.deliver(items, attempt + 1);
+      }
+    }
+  }
+  /** Re-attempt any envelopes that were parked while offline. */
+  async drainOfflineQueue() {
+    if (this.disabled || !this.offline.available) return;
+    const payloads = this.offline.drain();
+    for (const json of payloads) {
+      let outcome;
+      try {
+        outcome = await this.post(json);
+      } catch {
+        outcome = { action: "retry_backoff" };
+      }
+      if (outcome.action === "disable") {
+        this.onDisable();
+        this.offline.enqueue(json);
+        return;
+      }
+      if (outcome.action === "retry_after" || outcome.action === "retry_backoff") {
+        this.offline.enqueue(json);
+        return;
+      }
+    }
+  }
+  /** Best-effort synchronous-ish flush for page unload via `sendBeacon`. */
+  flushToBeacon() {
+    if (this.disabled) return;
+    const all = this.pending.splice(0, this.pending.length);
+    if (all.length === 0) return;
+    for (let i = 0; i < all.length; i += MAX_ITEMS_PER_ENVELOPE) {
+      this.beaconChunk(all.slice(i, i + MAX_ITEMS_PER_ENVELOPE));
+    }
+  }
+  beaconChunk(items) {
+    const json = safeStringify(this.makeEnvelope(items));
+    const nav = globalThis.navigator;
+    const size = byteLength(json);
+    if (nav && typeof nav.sendBeacon === "function" && size <= BEACON_MAX_BYTES) {
+      try {
+        const blob = new Blob([json], { type: "application/json" });
+        if (nav.sendBeacon(this.dsn.beaconUrl, blob)) return;
+      } catch {
+      }
+    }
+    this.offline.enqueue(json);
+  }
+  /** Compress (when large) and POST one serialized envelope. */
+  async post(json) {
+    const { body, encoding } = await maybeCompress(json);
+    const headers = {
+      "Content-Type": "application/json",
+      "X-Sauron-Key": this.dsn.publicKey
+    };
+    if (encoding) headers["Content-Encoding"] = encoding;
+    const size = typeof body === "string" ? byteLength(body) : body.byteLength;
+    const result = await this.doRequest(headers, body, size <= BEACON_MAX_BYTES);
+    return classifyStatus(result.status, result.retryAfter);
+  }
+  async doRequest(headers, body, keepalive) {
+    if (this.fetchImpl) {
+      beginInternal();
+      let promise;
+      try {
+        promise = this.fetchImpl(this.dsn.envelopeUrl, {
+          method: "POST",
+          headers,
+          body,
+          keepalive
+        });
+      } finally {
+        endInternal();
+      }
+      const res = await promise;
+      return { status: res.status, retryAfter: res.headers?.get?.("Retry-After") ?? null };
+    }
+    return this.xhrRequest(headers, body);
+  }
+  xhrRequest(headers, body) {
+    return new Promise((resolve, reject) => {
+      const XHR = globalThis.XMLHttpRequest;
+      if (typeof XHR !== "function") {
+        reject(new Error("no transport available"));
+        return;
+      }
+      beginInternal();
+      try {
+        const xhr = new XHR();
+        xhr.open("POST", this.dsn.envelopeUrl, true);
+        for (const key of Object.keys(headers)) {
+          try {
+            xhr.setRequestHeader(key, headers[key]);
+          } catch {
+          }
+        }
+        xhr.onload = () => resolve({ status: xhr.status, retryAfter: safeHeader(xhr, "Retry-After") });
+        xhr.onerror = () => reject(new Error("xhr network error"));
+        xhr.ontimeout = () => reject(new Error("xhr timeout"));
+        xhr.send(body);
+      } catch (err) {
+        reject(err instanceof Error ? err : new Error(String(err)));
+      } finally {
+        endInternal();
+      }
+    });
+  }
+  /** Offline queue accessor (used by tests / diagnostics). */
+  get offlineQueue() {
+    return this.offline;
+  }
+};
+function safeHeader(xhr, name) {
+  try {
+    return xhr.getResponseHeader(name);
+  } catch {
+    return null;
+  }
+}
+
+// src/client.ts
+var SauronClient = class {
+  constructor(options) {
+    __publicField(this, "options");
+    __publicField(this, "dsn");
+    __publicField(this, "scope");
+    __publicField(this, "transport");
+    __publicField(this, "logger");
+    __publicField(this, "nativeFetch");
+    __publicField(this, "enabled", true);
+    __publicField(this, "installed", false);
+    __publicField(this, "anonymousId", null);
+    __publicField(this, "beaconCleanup", null);
+    this.options = options;
+    this.dsn = parseDsn(options.dsn);
+    this.logger = makeLogger(options.debug);
+    this.scope = new Scope(options.maxBreadcrumbs);
+    this.scope.setTags(options.tags);
+    for (const [name, block] of Object.entries(options.contexts)) {
+      this.scope.setContext(name, block);
+    }
+    for (const [key, value] of Object.entries(options.extra)) {
+      this.scope.setExtra(key, value);
+    }
+    const g2 = globalThis;
+    this.nativeFetch = typeof g2.fetch === "function" ? g2.fetch.bind(globalThis) : void 0;
+    setDsnHost(this.dsn.host);
+    this.transport = new Transport({
+      dsn: this.dsn,
+      options: options.transport,
+      makeEnvelope: (items) => this.makeEnvelope(items),
+      fetchImpl: this.nativeFetch,
+      logger: this.logger,
+      onDisable: () => this.disable()
+    });
+  }
+  /** Install global handlers + auto-instrumentation and start the transport. */
+  install() {
+    if (this.installed) return;
+    this.installed = true;
+    getDeviceId();
+    getSessionId();
+    installGlobalHandlers();
+    installConsole();
+    installDom();
+    installHistory();
+    installFetch();
+    installXhr();
+    if (this.options.performance) installPerformance();
+    if (this.options.screen) setScreenState(this.options.screen);
+    if (this.options.screenTracking) {
+      onNavigation((path) => setScreen(path));
+    }
+    this.beaconCleanup = installBeacon(this.transport);
+    this.transport.start();
+    void this.transport.drainOfflineQueue();
+    this.logger.log("initialized", { dsn: this.dsn.host, project: this.dsn.projectId });
+  }
+  getScope() {
+    return this.scope;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  /** The current distinct id: the user id when identified, else an anon id. */
+  getDistinctId() {
+    const user = this.scope.getUser();
+    if (user.id) return user.id;
+    return this.ensureAnonymousId();
+  }
+  /** The anonymous id, or null if one was never needed. */
+  getAnonymousId() {
+    return this.anonymousId;
+  }
+  ensureAnonymousId() {
+    if (!this.anonymousId) this.anonymousId = `anon_${uuidv4()}`;
+    return this.anonymousId;
+  }
+  /** Stamp a fresh envelope (new `sent_at`, current context) around `items`. */
+  makeEnvelope(items) {
+    const header = {
+      dsn: this.dsn.raw,
+      sdk: { name: SDK_NAME, version: SDK_VERSION },
+      sent_at: nowIso(),
+      environment: this.options.environment,
+      release: this.options.release
+    };
+    const context = buildContext(this.options.release, this.scope.getUser());
+    return buildEnvelope(header, context, items);
+  }
+  /** Add a breadcrumb, running it through `beforeBreadcrumb` first. */
+  addBreadcrumb(breadcrumb, hint) {
+    if (!this.enabled) return;
+    let processed = breadcrumb;
+    if (this.options.beforeBreadcrumb) {
+      try {
+        processed = this.options.beforeBreadcrumb(breadcrumb, hint);
+      } catch (err) {
+        this.logger.warn("beforeBreadcrumb threw", err);
+        processed = breadcrumb;
+      }
+    }
+    if (!processed) return;
+    this.scope.addBreadcrumb(processed);
+  }
+  /**
+   * Reconcile an error item to the shared wire shape by filling the optional
+   * `event_id`/`message`/`tags`/`user` fields from the current scope and hint.
+   * Each field is left untouched when the item already sets it, and omitted
+   * entirely when there is nothing to attach (the backend defaults it) — only
+   * `event_id` is always minted so callers can correlate the report.
+   */
+  enrichErrorItem(item, hint) {
+    if (item.event_id === void 0) {
+      const hinted = hint?.event_id;
+      item.event_id = typeof hinted === "string" ? hinted : uuidv4();
+    }
+    if (item.message === void 0 && typeof hint?.message === "string") {
+      item.message = hint.message;
+    }
+    const tags = mergeMeta(this.scope.tags, item.tags);
+    if (Object.keys(tags).length > 0) item.tags = tags;
+    const contexts = mergeMeta(this.scope.contexts, item.contexts);
+    if (Object.keys(contexts).length > 0) item.contexts = contexts;
+    const extra = mergeMeta(this.scope.extra, item.extra);
+    if (Object.keys(extra).length > 0) item.extra = extra;
+    if (item.user === void 0 && this.scope.hasUser()) {
+      item.user = this.scope.getUser();
+    }
+  }
+  /**
+   * Run an item through sampling (errors only) and `beforeSend`, then hand it to
+   * the transport. Returns silently when dropped.
+   */
+  captureItem(item, hint) {
+    if (!this.enabled) return;
+    if (item.type === "error") {
+      if (Math.random() >= this.options.sampleRate) {
+        this.logger.log("dropped error by sampleRate");
+        return;
+      }
+      this.enrichErrorItem(item, hint);
+    }
+    let processed = item;
+    if (this.options.beforeSend) {
+      try {
+        processed = this.options.beforeSend(item, hint);
+      } catch (err) {
+        this.logger.warn("beforeSend threw", err);
+        processed = item;
+      }
+    }
+    if (!processed) {
+      this.logger.log("dropped by beforeSend");
+      return;
+    }
+    this.transport.send(processed);
+  }
+  /** Flush pending events. Resolves false if `timeoutMs` elapses first. */
+  flush(timeoutMs) {
+    return this.transport.flush(timeoutMs);
+  }
+  /** Disable the client (called on 401/403). Stops accepting/sending events. */
+  disable() {
+    if (!this.enabled) return;
+    this.enabled = false;
+    this.transport.disable();
+    this.logger.warn("client disabled");
+  }
+  /** Restore all patched globals and stop timers/listeners. */
+  teardown() {
+    this.enabled = false;
+    this.transport.stop();
+    if (this.beaconCleanup) {
+      this.beaconCleanup();
+      this.beaconCleanup = null;
+    }
+    onNavigation(null);
+    resetScreen();
+    unpatchAll();
+    setDsnHost(null);
+    this.installed = false;
+  }
+  /** Flush then tear down. Resolves to the flush result. */
+  async close(timeoutMs) {
+    const flushed = await this.transport.flush(timeoutMs);
+    this.teardown();
+    return flushed;
+  }
+};
+var currentClient = null;
+function getClient() {
+  return currentClient;
+}
+function resolveOptions(options) {
+  if (!options || typeof options.dsn !== "string" || options.dsn.length === 0) {
+    throw new Error("[sauron] init() requires a `dsn`");
+  }
+  const t = options.transport ?? {};
+  return {
+    dsn: options.dsn,
+    environment: options.environment ?? "production",
+    release: options.release ?? null,
+    sampleRate: clamp(options.sampleRate ?? 1, 0, 1),
+    maxBreadcrumbs: options.maxBreadcrumbs ?? 50,
+    tags: options.tags ?? {},
+    contexts: options.contexts ?? {},
+    extra: options.extra ?? {},
+    beforeSend: options.beforeSend,
+    beforeBreadcrumb: options.beforeBreadcrumb,
+    transport: {
+      flushIntervalMs: t.flushIntervalMs ?? 5e3,
+      maxBatch: t.maxBatch ?? 30,
+      maxQueueBytes: t.maxQueueBytes ?? 1048576
+    },
+    performance: options.performance ?? false,
+    screen: options.screen,
+    screenTracking: options.screenTracking ?? false,
+    debug: options.debug ?? false
+  };
+}
+function init(options) {
+  if (currentClient) {
+    try {
+      currentClient.teardown();
+    } catch {
+    }
+  }
+  const resolved = resolveOptions(options);
+  const client = new SauronClient(resolved);
+  currentClient = client;
+  client.install();
+  return client;
+}
+
+// src/api/breadcrumbs.ts
+function normalizeBreadcrumb(input) {
+  return {
+    type: input.type ?? "default",
+    category: input.category ?? "default",
+    message: input.message ?? null,
+    level: input.level ?? "info",
+    timestamp: input.timestamp ?? nowIso(),
+    data: input.data ?? null
+  };
+}
+function addBreadcrumb(input, hint) {
+  const client = getClient();
+  if (!client) return;
+  client.addBreadcrumb(normalizeBreadcrumb(input), hint);
+}
+function addNavigationBreadcrumb(from, to) {
+  addBreadcrumb({
+    type: "navigation",
+    category: "history",
+    level: "info",
+    message: null,
+    data: { from, to }
+  });
+}
+
+// src/index.ts
+function init2(options) {
+  return init(options);
+}
+function captureException2(err, hint) {
+  captureException(err, hint);
+}
+function captureMessage2(message, level = "info", hint) {
+  captureMessage(message, level, hint);
+}
+function track2(name, properties, options) {
+  track(name, properties, options);
+}
+function identify2(id, traits) {
+  identify(id, traits);
+}
+function trackTransaction2(input) {
+  trackTransaction(input);
+}
+function setScreen2(name) {
+  setScreen(name);
+}
+function getScreen2() {
+  return getScreen();
+}
+function addBreadcrumb2(breadcrumb, hint) {
+  addBreadcrumb(breadcrumb, hint);
+}
+function setUser(user) {
+  getClient()?.getScope().setUser(user);
+}
+function setTag(key, value) {
+  getClient()?.getScope().setTag(key, value);
+}
+function setTags(tags) {
+  getClient()?.getScope().setTags(tags);
+}
+function setContext(name, block) {
+  getClient()?.getScope().setContext(name, block);
+}
+function setExtra(key, value) {
+  getClient()?.getScope().setExtra(key, value);
+}
+function flush(timeoutMs) {
+  const client = getClient();
+  return client ? client.flush(timeoutMs) : Promise.resolve(false);
+}
+function close(timeoutMs) {
+  const client = getClient();
+  return client ? client.close(timeoutMs) : Promise.resolve(false);
+}
+var Sauron = {
+  init: init2,
+  captureException: captureException2,
+  captureMessage: captureMessage2,
+  track: track2,
+  trackTransaction: trackTransaction2,
+  identify: identify2,
+  addBreadcrumb: addBreadcrumb2,
+  setUser,
+  setTag,
+  setTags,
+  setContext,
+  setExtra,
+  setScreen: setScreen2,
+  getScreen: getScreen2,
+  flush,
+  close,
+  getClient
+};
+var index_default = Sauron;
+
+export { DsnError, SDK_NAME, SDK_VERSION, Sauron, SauronClient, addBreadcrumb2 as addBreadcrumb, buildEnvelope, captureException2 as captureException, captureMessage2 as captureMessage, close, index_default as default, flush, getClient, getScreen2 as getScreen, identify2 as identify, init2 as init, isInAppFrame, parseDsn, parseError, parseStackString, setContext, setExtra, setScreen2 as setScreen, setTag, setTags, setUser, track2 as track, trackTransaction2 as trackTransaction };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map