@allstak/react 0.1.3 → 0.3.0

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,16 +17,1848 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AllStak: () => import_react.AllStak,
-  AllStakErrorBoundary: () => import_react.AllStakErrorBoundary,
-  useAllStak: () => import_react.useAllStak,
-  withAllStakProfiler: () => import_react.withAllStakProfiler
+  AllStak: () => AllStak,
+  AllStakClient: () => AllStakClient,
+  AllStakErrorBoundary: () => AllStakErrorBoundary,
+  HttpRequestModule: () => HttpRequestModule,
+  INGEST_HOST: () => INGEST_HOST,
+  ReplayRecorder: () => ReplayRecorder,
+  SDK_NAME: () => SDK_NAME,
+  SDK_VERSION: () => SDK_VERSION,
+  Scope: () => Scope,
+  instrumentBrowserNavigation: () => instrumentBrowserNavigation,
+  instrumentConsole: () => instrumentConsole,
+  instrumentFetch: () => instrumentFetch,
+  instrumentNextRouter: () => instrumentNextRouter,
+  instrumentReactRouter: () => instrumentReactRouter,
+  useAllStak: () => useAllStak,
+  withAllStakProfiler: () => withAllStakProfiler
 });
 module.exports = __toCommonJS(index_exports);
-var import_react = require("@allstak/js/react");
+var React = __toESM(require("react"));
+
+// src/transport.ts
+var REQUEST_TIMEOUT = 3e3;
+var MAX_BUFFER = 100;
+var HttpTransport = class {
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.buffer = [];
+    this.flushing = false;
+  }
+  async send(path, payload) {
+    try {
+      await this.doFetch(path, payload);
+      await this.flushBuffer();
+    } catch {
+      if (this.buffer.length >= MAX_BUFFER) this.buffer.shift();
+      this.buffer.push({ path, payload });
+    }
+  }
+  async doFetch(path, payload) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-AllStak-Key": this.apiKey
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal
+      });
+      if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async flushBuffer() {
+    if (this.flushing || this.buffer.length === 0) return;
+    this.flushing = true;
+    try {
+      const items = this.buffer.splice(0, this.buffer.length);
+      for (const item of items) {
+        try {
+          await this.doFetch(item.path, item.payload);
+        } catch {
+        }
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+  getBufferSize() {
+    return this.buffer.length;
+  }
+  /**
+   * Wait for the in-flight retry-buffer to drain. Resolves `true` if the
+   * buffer empties within `timeoutMs` (default 2000ms), `false` otherwise.
+   * Useful at process exit / before navigation away.
+   */
+  async flush(timeoutMs = 2e3) {
+    const deadline = Date.now() + timeoutMs;
+    await this.flushBuffer();
+    while (this.buffer.length > 0 || this.flushing) {
+      if (Date.now() >= deadline) return false;
+      await new Promise((r) => setTimeout(r, 25));
+      await this.flushBuffer();
+    }
+    return true;
+  }
+};
+
+// src/stack.ts
+var V8_FRAME_RE = /^\s*at\s+(?:(.+?)\s+\()?((?:.+?):(\d+):(\d+))\)?\s*$/;
+var GECKO_FRAME_RE = /^\s*(?:(.*?)@)?(.+?):(\d+):(\d+)\s*$/;
+var NODE_INTERNAL_RE = /^(node:|internal\/|node_modules\/)/;
+function parseStack(stack) {
+  if (!stack || typeof stack !== "string") return [];
+  const frames = [];
+  for (const raw of stack.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    let m = V8_FRAME_RE.exec(line);
+    if (m) {
+      const filename = stripQueryHash(m[2].replace(/:\d+:\d+$/, ""));
+      frames.push({
+        filename,
+        absPath: filename,
+        function: m[1] ? m[1].trim() : void 0,
+        lineno: parseInt(m[3], 10),
+        colno: parseInt(m[4], 10),
+        inApp: isInApp(filename)
+      });
+      continue;
+    }
+    m = GECKO_FRAME_RE.exec(line);
+    if (m && m[2]) {
+      const filename = stripQueryHash(m[2]);
+      frames.push({
+        filename,
+        absPath: filename,
+        function: m[1] ? m[1].trim() : void 0,
+        lineno: parseInt(m[3], 10),
+        colno: parseInt(m[4], 10),
+        inApp: isInApp(filename)
+      });
+    }
+  }
+  return frames;
+}
+function stripQueryHash(url) {
+  const q = url.indexOf("?");
+  const h = url.indexOf("#");
+  let cut = url.length;
+  if (q >= 0) cut = Math.min(cut, q);
+  if (h >= 0) cut = Math.min(cut, h);
+  return url.slice(0, cut);
+}
+function isInApp(filename) {
+  if (!filename) return true;
+  if (NODE_INTERNAL_RE.test(filename)) return false;
+  if (filename.includes("/node_modules/")) return false;
+  return true;
+}
+
+// src/auto-breadcrumbs.ts
+var FETCH_FLAG = "__allstak_fetch_patched__";
+var CONSOLE_FLAG = "__allstak_console_patched__";
+function instrumentFetch(addBreadcrumb, ownBaseUrl) {
+  const g = globalThis;
+  if (typeof g.fetch !== "function") return;
+  if (g.fetch[FETCH_FLAG]) return;
+  const originalFetch = g.fetch;
+  const wrapped = async function(input, init) {
+    const method = (init?.method || input && typeof input === "object" && input.method || "GET").toUpperCase();
+    let url;
+    if (typeof input === "string") url = input;
+    else if (input && typeof input.href === "string") url = input.href;
+    else if (input && typeof input.url === "string") url = input.url;
+    else url = String(input);
+    const safePath = url.split("?")[0];
+    const isOwnIngest2 = !!(ownBaseUrl && url.startsWith(ownBaseUrl));
+    const start = Date.now();
+    try {
+      const response = await originalFetch.call(this, input, init);
+      const durationMs = Date.now() - start;
+      if (!isOwnIngest2) {
+        addBreadcrumb(
+          "http",
+          `${method} ${safePath} -> ${response.status}`,
+          response.status >= 400 ? "error" : "info",
+          { method, url: safePath, statusCode: response.status, durationMs }
+        );
+      }
+      return response;
+    } catch (err) {
+      const durationMs = Date.now() - start;
+      if (!isOwnIngest2) {
+        addBreadcrumb("http", `${method} ${safePath} -> failed`, "error", {
+          method,
+          url: safePath,
+          error: String(err),
+          durationMs
+        });
+      }
+      throw err;
+    }
+  };
+  wrapped[FETCH_FLAG] = true;
+  g.fetch = wrapped;
+}
+function instrumentConsole(addBreadcrumb) {
+  if (typeof console === "undefined") return;
+  if (console[CONSOLE_FLAG]) return;
+  const origWarn = console.warn;
+  const origError = console.error;
+  console.warn = function(...args) {
+    try {
+      addBreadcrumb("log", args.map(safeString).join(" "), "warn");
+    } catch {
+    }
+    return origWarn.apply(console, args);
+  };
+  console.error = function(...args) {
+    try {
+      addBreadcrumb("log", args.map(safeString).join(" "), "error");
+    } catch {
+    }
+    return origError.apply(console, args);
+  };
+  console[CONSOLE_FLAG] = true;
+}
+function safeString(v) {
+  if (v == null) return String(v);
+  if (typeof v === "string") return v;
+  if (v instanceof Error) return `${v.name}: ${v.message}`;
+  try {
+    return typeof v === "object" ? JSON.stringify(v) : String(v);
+  } catch {
+    return Object.prototype.toString.call(v);
+  }
+}
+
+// src/navigation.ts
+var FLAG = "__allstak_history_patched__";
+function instrumentBrowserNavigation(addBreadcrumb) {
+  if (typeof window === "undefined" || typeof history === "undefined") return;
+  if (history[FLAG]) return;
+  const emit = (from, to) => {
+    if (from === to) return;
+    try {
+      addBreadcrumb("navigation", `${from} -> ${to}`, "info", { from, to });
+    } catch {
+    }
+  };
+  const origPush = history.pushState.bind(history);
+  const origReplace = history.replaceState.bind(history);
+  history.pushState = function(state, unused, url) {
+    const from = location.pathname + location.search;
+    const ret = origPush(state, unused, url ?? null);
+    emit(from, location.pathname + location.search);
+    return ret;
+  };
+  history.replaceState = function(state, unused, url) {
+    const from = location.pathname + location.search;
+    const ret = origReplace(state, unused, url ?? null);
+    emit(from, location.pathname + location.search);
+    return ret;
+  };
+  let last = location.pathname + location.search;
+  window.addEventListener("popstate", () => {
+    const next = location.pathname + location.search;
+    emit(last, next);
+    last = next;
+  });
+  history[FLAG] = true;
+}
+var lastReactRouterPath;
+function instrumentReactRouter(location2, addBreadcrumb = (...args) => __defaultBreadcrumb(...args)) {
+  const next = `${location2.pathname}${location2.search ?? ""}`;
+  if (next === lastReactRouterPath) return;
+  const from = lastReactRouterPath ?? "<initial>";
+  lastReactRouterPath = next;
+  try {
+    addBreadcrumb("navigation", `${from} -> ${next}`, "info", { router: "react-router", from, to: next });
+  } catch {
+  }
+}
+var lastNextPath;
+function instrumentNextRouter(url, addBreadcrumb = (...args) => __defaultBreadcrumb(...args)) {
+  if (url === lastNextPath) return;
+  const from = lastNextPath ?? "<initial>";
+  lastNextPath = url;
+  try {
+    addBreadcrumb("navigation", `${from} -> ${url}`, "info", { router: "next", from, to: url });
+  } catch {
+  }
+}
+var __defaultBreadcrumb = () => {
+};
+function __setDefaultBreadcrumbForwarder(fn) {
+  __defaultBreadcrumb = fn;
+}
+
+// src/scope.ts
+var Scope = class {
+  constructor() {
+    this.tags = {};
+    this.extras = {};
+    this.contexts = {};
+  }
+  setUser(user) {
+    this.user = user;
+    return this;
+  }
+  setTag(key, value) {
+    this.tags[key] = value;
+    return this;
+  }
+  setTags(tags) {
+    Object.assign(this.tags, tags);
+    return this;
+  }
+  setExtra(key, value) {
+    this.extras[key] = value;
+    return this;
+  }
+  setExtras(extras) {
+    Object.assign(this.extras, extras);
+    return this;
+  }
+  setContext(name, ctx) {
+    if (ctx === null) delete this.contexts[name];
+    else this.contexts[name] = ctx;
+    return this;
+  }
+  setLevel(level) {
+    this.level = level;
+    return this;
+  }
+  setFingerprint(fingerprint) {
+    this.fingerprint = fingerprint && fingerprint.length > 0 ? fingerprint : void 0;
+    return this;
+  }
+  clear() {
+    this.user = void 0;
+    this.tags = {};
+    this.extras = {};
+    this.contexts = {};
+    this.fingerprint = void 0;
+    this.level = void 0;
+    return this;
+  }
+};
+function mergeScopes(base, stack) {
+  const out = { ...base };
+  out.tags = { ...base.tags ?? {} };
+  out.extras = { ...base.extras ?? {} };
+  out.contexts = { ...base.contexts ?? {} };
+  for (const scope of stack) {
+    if (scope.user) out.user = scope.user;
+    Object.assign(out.tags, scope.tags);
+    Object.assign(out.extras, scope.extras);
+    Object.assign(out.contexts, scope.contexts);
+    if (scope.fingerprint) out.fingerprint = scope.fingerprint;
+    if (scope.level) out.level = scope.level;
+  }
+  return out;
+}
+
+// src/tracing.ts
+var SPAN_INGEST_PATH = "/ingest/v1/spans";
+var FLUSH_INTERVAL_MS = 5e3;
+var BATCH_SIZE_THRESHOLD = 20;
+function id() {
+  const hex = (n) => Math.floor(Math.random() * n).toString(16).padStart(1, "0");
+  const seg = (len) => Array.from({ length: len }, () => hex(16)).join("");
+  return `${seg(8)}-${seg(4)}-4${seg(3)}-${(8 + Math.floor(Math.random() * 4)).toString(16)}${seg(3)}-${seg(12)}`;
+}
+var Span = class {
+  constructor(_traceId, _spanId, _parentSpanId, _operation, _description, _service, _environment, _tags, _onFinish) {
+    this._traceId = _traceId;
+    this._spanId = _spanId;
+    this._parentSpanId = _parentSpanId;
+    this._operation = _operation;
+    this._description = _description;
+    this._service = _service;
+    this._environment = _environment;
+    this._tags = _tags;
+    this._onFinish = _onFinish;
+    this._finished = false;
+    this._data = "";
+    this._startTimeMillis = Date.now();
+  }
+  setTag(key, value) {
+    this._tags[key] = value;
+    return this;
+  }
+  setData(data) {
+    this._data = data;
+    return this;
+  }
+  setDescription(description) {
+    this._description = description;
+    return this;
+  }
+  finish(status = "ok") {
+    if (this._finished) return;
+    this._finished = true;
+    const endTimeMillis = Date.now();
+    this._onFinish({
+      traceId: this._traceId,
+      spanId: this._spanId,
+      parentSpanId: this._parentSpanId,
+      operation: this._operation,
+      description: this._description,
+      status,
+      durationMs: endTimeMillis - this._startTimeMillis,
+      startTimeMillis: this._startTimeMillis,
+      endTimeMillis,
+      service: this._service,
+      environment: this._environment,
+      tags: this._tags,
+      data: this._data
+    });
+  }
+  get traceId() {
+    return this._traceId;
+  }
+  get spanId() {
+    return this._spanId;
+  }
+  get isFinished() {
+    return this._finished;
+  }
+};
+var NoopSpan = class extends Span {
+  constructor(traceId, spanId) {
+    super(traceId, spanId, "", "", "", "", "", {}, () => {
+    });
+  }
+  finish() {
+  }
+};
+var TracingModule = class {
+  constructor(transport, opts) {
+    this.transport = transport;
+    this.opts = opts;
+    this.spans = [];
+    this.flushTimer = null;
+    this.currentTraceId = null;
+    this.spanStack = [];
+    this.destroyed = false;
+  }
+  /** Get (and lazily create) the active trace ID. */
+  getTraceId() {
+    if (!this.currentTraceId) this.currentTraceId = id();
+    return this.currentTraceId;
+  }
+  /** Override the active trace ID, e.g. from an inbound request header. */
+  setTraceId(traceId) {
+    this.currentTraceId = traceId;
+  }
+  /** Get the active span's ID, or null if no span is active. */
+  getCurrentSpanId() {
+    return this.spanStack.length > 0 ? this.spanStack[this.spanStack.length - 1].spanId : null;
+  }
+  /** Reset both the trace ID and the in-flight span stack. */
+  resetTrace() {
+    this.currentTraceId = null;
+    this.spanStack = [];
+  }
+  /**
+   * Start a new span. The returned Span automatically inherits the active
+   * span as its parent. If `tracesSampleRate` drops this trace, returns a
+   * no-op Span so the call site doesn't have to null-check.
+   */
+  startSpan(operation, options = {}) {
+    const traceId = this.getTraceId();
+    const spanId = id();
+    const parentSpanId = this.getCurrentSpanId() ?? "";
+    if (!this.passesSampleRate()) {
+      return new NoopSpan(traceId, spanId);
+    }
+    const span = new Span(
+      traceId,
+      spanId,
+      parentSpanId,
+      operation,
+      options.description ?? "",
+      this.opts.service ?? "",
+      this.opts.environment ?? "",
+      { ...options.tags ?? {} },
+      (data) => this.enqueue(data, span)
+    );
+    this.spanStack.push(span);
+    return span;
+  }
+  passesSampleRate() {
+    const r = this.opts.tracesSampleRate;
+    if (typeof r !== "number" || r >= 1) return true;
+    if (r <= 0) return false;
+    return Math.random() < r;
+  }
+  enqueue(data, span) {
+    if (this.destroyed) return;
+    const idx = this.spanStack.lastIndexOf(span);
+    if (idx >= 0) this.spanStack.splice(idx, 1);
+    this.spans.push(data);
+    if (this.spans.length >= BATCH_SIZE_THRESHOLD) {
+      this.flush();
+      return;
+    }
+    if (!this.flushTimer) {
+      this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS);
+    }
+  }
+  flush() {
+    if (this.spans.length === 0) return;
+    const batch = this.spans;
+    this.spans = [];
+    this.transport.send(SPAN_INGEST_PATH, { spans: batch });
+  }
+  destroy() {
+    this.destroyed = true;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flush();
+    this.currentTraceId = null;
+    this.spanStack = [];
+  }
+};
+
+// src/replay.ts
+var REPLAY_INGEST_PATH = "/ingest/v1/replay";
+var FLUSH_INTERVAL_MS2 = 1e4;
+var DEFAULT_MASK_ATTR = "data-allstak-mask";
+var FLAG2 = "__allstak_replay_started__";
+var ReplayRecorder = class {
+  constructor(transport, sessionId, addBreadcrumb, options = {}) {
+    this.transport = transport;
+    this.addBreadcrumb = addBreadcrumb;
+    this.buffer = [];
+    this.flushTimer = null;
+    this.observer = null;
+    this.inputListener = null;
+    this.destroyed = false;
+    this.sessionId = sessionId;
+    this.opts = {
+      enabled: options.enabled ?? true,
+      sampleRate: options.sampleRate ?? 0,
+      maskAllInputs: options.maskAllInputs ?? true,
+      maskAttribute: options.maskAttribute ?? DEFAULT_MASK_ATTR,
+      maxBufferedEvents: options.maxBufferedEvents ?? 200
+    };
+  }
+  start() {
+    if (typeof document === "undefined" || typeof window === "undefined") return;
+    if (!this.opts.enabled) return;
+    if (Math.random() >= this.opts.sampleRate) return;
+    if (document[FLAG2]) return;
+    document[FLAG2] = true;
+    this.push({
+      ts: Date.now(),
+      k: "snap",
+      data: { html: this.snapshotBody(), url: location.href }
+    });
+    this.observer = new MutationObserver((records) => {
+      for (const r of records) {
+        if (r.type === "childList") {
+          this.push({
+            ts: Date.now(),
+            k: "mut",
+            data: {
+              kind: "childList",
+              target: this.describePath(r.target),
+              added: Array.from(r.addedNodes).map((n) => this.describeNode(n)),
+              removed: r.removedNodes.length
+            }
+          });
+        } else if (r.type === "attributes") {
+          this.push({
+            ts: Date.now(),
+            k: "mut",
+            data: {
+              kind: "attr",
+              target: this.describePath(r.target),
+              name: r.attributeName,
+              value: this.safeAttribute(r.target, r.attributeName ?? "")
+            }
+          });
+        }
+      }
+    });
+    this.observer.observe(document.body ?? document.documentElement, {
+      childList: true,
+      attributes: true,
+      subtree: true
+    });
+    this.inputListener = (ev) => {
+      const target = ev.target;
+      if (!target || !("value" in target)) return;
+      const masked = this.maskInputValue(target);
+      this.push({
+        ts: Date.now(),
+        k: "input",
+        data: { target: this.describePath(target), value: masked, type: target.type }
+      });
+    };
+    document.addEventListener("input", this.inputListener, true);
+    this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS2);
+    try {
+      this.addBreadcrumb("default", "Replay recording started", "info", { sessionId: this.sessionId });
+    } catch {
+    }
+  }
+  destroy() {
+    this.destroyed = true;
+    if (this.observer) {
+      this.observer.disconnect();
+      this.observer = null;
+    }
+    if (this.inputListener) {
+      document.removeEventListener("input", this.inputListener, true);
+      this.inputListener = null;
+    }
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flush();
+    if (typeof document !== "undefined") document[FLAG2] = false;
+  }
+  /** @internal — exposed for tests. */
+  getBuffer() {
+    return this.buffer;
+  }
+  push(ev) {
+    if (this.destroyed) return;
+    this.buffer.push(ev);
+    if (this.buffer.length >= this.opts.maxBufferedEvents) this.flush();
+  }
+  flush() {
+    if (this.buffer.length === 0) return;
+    const events = this.buffer;
+    this.buffer = [];
+    this.transport.send(REPLAY_INGEST_PATH, {
+      sessionId: this.sessionId,
+      events
+    });
+  }
+  // ── Sanitization helpers ──────────────────────────────────────────
+  snapshotBody() {
+    if (!document.body) return "";
+    const clone = document.body.cloneNode(true);
+    this.maskTree(clone);
+    return clone.outerHTML;
+  }
+  maskTree(root) {
+    if (this.opts.maskAttribute && root.hasAttribute?.(this.opts.maskAttribute)) {
+      root.textContent = "***";
+      return;
+    }
+    const tag = root.tagName?.toLowerCase();
+    if (tag === "input" || tag === "textarea" || tag === "select") {
+      root.value = this.maskInputValue(root);
+      root.setAttribute("value", root.value);
+    }
+    for (const child of Array.from(root.children)) this.maskTree(child);
+  }
+  maskInputValue(el) {
+    if (el.type === "password") return "***";
+    if (this.opts.maskAllInputs) return "***";
+    return String(el.value ?? "");
+  }
+  describeNode(node) {
+    if (node.nodeType === 1) {
+      return { type: "element", tag: node.tagName?.toLowerCase() };
+    }
+    if (node.nodeType === 3) {
+      return { type: "text", length: (node.nodeValue ?? "").length };
+    }
+    return { type: "other" };
+  }
+  describePath(el) {
+    if (!el || el.nodeType !== 1) return "";
+    const parts = [];
+    let cur = el;
+    let depth = 0;
+    while (cur && depth < 8) {
+      let p = cur.tagName.toLowerCase();
+      if (cur.id) {
+        p += `#${cur.id}`;
+        parts.unshift(p);
+        break;
+      }
+      if (cur.classList?.length) p += "." + Array.from(cur.classList).slice(0, 2).join(".");
+      parts.unshift(p);
+      cur = cur.parentElement;
+      depth += 1;
+    }
+    return parts.join(">");
+  }
+  safeAttribute(el, name) {
+    if (name === "value" || name === "defaultValue") return "***";
+    return el.getAttribute(name) ?? "";
+  }
+};
+
+// src/debug-id.ts
+function getRegistry() {
+  return globalThis._allstakDebugIds ?? {};
+}
+var cache = /* @__PURE__ */ new Map();
+function resolveDebugId(filename) {
+  if (!filename) return void 0;
+  if (cache.has(filename)) return cache.get(filename);
+  const registry = getRegistry();
+  let id2 = registry[filename];
+  if (!id2) {
+    for (const key of Object.keys(registry)) {
+      if (filename.endsWith(key)) {
+        id2 = registry[key];
+        break;
+      }
+    }
+  }
+  cache.set(filename, id2);
+  return id2;
+}
+
+// src/http-requests.ts
+var INGEST_PATH = "/ingest/v1/http-requests";
+var FLUSH_INTERVAL_MS3 = 5e3;
+var BATCH_SIZE_THRESHOLD2 = 20;
+var RECENT_FAILED_BUFFER_SIZE = 10;
+function genTraceId() {
+  const hex = (n) => Math.floor(Math.random() * n).toString(16).padStart(1, "0");
+  const seg = (len) => Array.from({ length: len }, () => hex(16)).join("");
+  return `${seg(8)}-${seg(4)}-4${seg(3)}-${(8 + Math.floor(Math.random() * 4)).toString(16)}${seg(3)}-${seg(12)}`;
+}
+function splitHostPath(url) {
+  try {
+    const u = new URL(url);
+    return { host: u.host, path: u.pathname || "/" };
+  } catch {
+    return { host: "", path: url.split("?")[0] };
+  }
+}
+var HttpRequestModule = class {
+  constructor(transport) {
+    this.transport = transport;
+    this.queue = [];
+    this.recentFailed = [];
+    this.flushTimer = null;
+    this.destroyed = false;
+    this.defaults = {};
+  }
+  setDefaults(defaults) {
+    this.defaults = { ...this.defaults, ...defaults };
+  }
+  capture(ev) {
+    if (this.destroyed) return;
+    const { host, path } = splitHostPath(ev.url);
+    const item = {
+      type: "http_request",
+      traceId: ev.traceId ?? genTraceId(),
+      direction: "outbound",
+      method: (ev.method || "GET").toUpperCase(),
+      host,
+      path,
+      url: ev.url,
+      statusCode: ev.statusCode ?? 0,
+      durationMs: Math.max(0, Math.floor(ev.durationMs)),
+      requestSize: ev.requestSize,
+      responseSize: ev.responseSize,
+      requestBody: ev.requestBody,
+      responseBody: ev.responseBody,
+      requestHeaders: ev.requestHeaders,
+      responseHeaders: ev.responseHeaders,
+      error: ev.error,
+      environment: this.defaults.environment,
+      release: this.defaults.release,
+      dist: this.defaults.dist,
+      platform: this.defaults.platform,
+      "sdk.name": this.defaults.sdkName,
+      "sdk.version": this.defaults.sdkVersion,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.queue.push(item);
+    const isFailed = item.statusCode >= 400 || !!item.error;
+    if (isFailed) {
+      this.recentFailed.push(item);
+      if (this.recentFailed.length > RECENT_FAILED_BUFFER_SIZE) this.recentFailed.shift();
+    }
+    if (this.queue.length >= BATCH_SIZE_THRESHOLD2) {
+      this.flush();
+      return;
+    }
+    if (!this.flushTimer) this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS3);
+  }
+  /** Snapshot of the last failed requests for error-linking. Newest last. */
+  getRecentFailed() {
+    return this.recentFailed;
+  }
+  flush() {
+    if (this.queue.length === 0) return;
+    const batch = this.queue;
+    this.queue = [];
+    const payload = { requests: batch };
+    this.transport.send(INGEST_PATH, payload);
+  }
+  destroy() {
+    this.destroyed = true;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flush();
+    this.recentFailed = [];
+  }
+  /** @internal — for tests. */
+  getQueueSize() {
+    return this.queue.length;
+  }
+};
+
+// src/http-redact.ts
+var ALWAYS_REDACT_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "x-auth-token",
+  "proxy-authorization"
+]);
+var ALWAYS_REDACT_QUERY = /* @__PURE__ */ new Set([
+  "token",
+  "password",
+  "api_key",
+  "apikey",
+  "authorization",
+  "auth",
+  "secret",
+  "access_token",
+  "refresh_token",
+  "session",
+  "sessionid",
+  "jwt"
+]);
+var REDACTED = "[REDACTED]";
+function shouldCaptureUrl(url, opts) {
+  if (!url) return false;
+  const lower = url.toLowerCase();
+  if (opts.allowedUrls && opts.allowedUrls.length > 0) {
+    return opts.allowedUrls.some((p) => matches(p, url, lower));
+  }
+  if (opts.ignoredUrls && opts.ignoredUrls.length > 0) {
+    return !opts.ignoredUrls.some((p) => matches(p, url, lower));
+  }
+  return true;
+}
+function matches(pattern, url, lower) {
+  if (pattern instanceof RegExp) return pattern.test(url);
+  if (typeof pattern !== "string") return false;
+  return lower.includes(pattern.toLowerCase());
+}
+function redactUrl(url, opts) {
+  if (!url) return url;
+  const extra = (opts.redactQueryParams ?? []).map((s) => s.toLowerCase());
+  const redactSet = /* @__PURE__ */ new Set([...ALWAYS_REDACT_QUERY, ...extra]);
+  let parsed = null;
+  try {
+    parsed = new URL(url);
+  } catch {
+  }
+  if (parsed) {
+    const params = parsed.searchParams;
+    let mutated = false;
+    const keysToRedact = [];
+    params.forEach((_v, k) => {
+      if (redactSet.has(k.toLowerCase())) keysToRedact.push(k);
+    });
+    for (const k of keysToRedact) {
+      params.set(k, REDACTED);
+      mutated = true;
+    }
+    if (mutated) parsed.search = params.toString();
+    return parsed.toString();
+  }
+  const qIdx = url.indexOf("?");
+  if (qIdx < 0) return url;
+  const head = url.slice(0, qIdx);
+  const queryAndHash = url.slice(qIdx + 1);
+  const hashIdx = queryAndHash.indexOf("#");
+  const query = hashIdx < 0 ? queryAndHash : queryAndHash.slice(0, hashIdx);
+  const hash = hashIdx < 0 ? "" : queryAndHash.slice(hashIdx);
+  const parts = query.split("&").map((pair) => {
+    const eq = pair.indexOf("=");
+    if (eq < 0) return pair;
+    const key = pair.slice(0, eq);
+    return redactSet.has(key.toLowerCase()) ? `${key}=${REDACTED}` : pair;
+  });
+  return `${head}?${parts.join("&")}${hash ? "#" + hash : ""}`;
+}
+function sanitizeHeaders(headers, opts) {
+  if (!opts.captureHeaders) return void 0;
+  if (!headers) return {};
+  const extra = (opts.redactHeaders ?? []).map((s) => s.toLowerCase());
+  const redactSet = /* @__PURE__ */ new Set([...ALWAYS_REDACT_HEADERS, ...extra]);
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    if (v == null) continue;
+    const lower = k.toLowerCase();
+    out[lower] = redactSet.has(lower) ? REDACTED : Array.isArray(v) ? v.join(", ") : String(v);
+  }
+  return out;
+}
+function captureBody(body, enabled, maxBodyBytes) {
+  if (!enabled) return void 0;
+  if (body == null) return void 0;
+  let str;
+  if (typeof body === "string") str = body;
+  else if (typeof body === "number" || typeof body === "boolean") str = String(body);
+  else if (typeof body === "object") {
+    const tag = Object.prototype.toString.call(body);
+    if (tag !== "[object Object]" && tag !== "[object Array]") return "<binary>";
+    try {
+      str = JSON.stringify(body);
+    } catch {
+      return "<unserializable>";
+    }
+  } else {
+    return "<binary>";
+  }
+  if (str.length > maxBodyBytes) return str.slice(0, maxBodyBytes) + "\u2026[truncated]";
+  return str;
+}
+
+// src/http-instrumentation.ts
+var FETCH_FLAG2 = "__allstak_http_fetch_patched__";
+var XHR_FLAG = "__allstak_http_xhr_patched__";
+var AXIOS_FLAG = /* @__PURE__ */ Symbol.for("allstak.http.axios.instrumented");
+var DEFAULT_MAX_BODY = 4096;
+var _currentModule = null;
+var _currentOpts = null;
+function currentModule() {
+  return _currentModule;
+}
+function currentOpts() {
+  return _currentOpts;
+}
+function safeCapture(ev) {
+  try {
+    currentModule()?.capture(ev);
+  } catch {
+  }
+}
+function bind(opts, ownIngestHost) {
+  return {
+    captureRequestBody: opts.captureRequestBody ?? false,
+    captureResponseBody: opts.captureResponseBody ?? false,
+    captureHeaders: opts.captureHeaders ?? false,
+    redactHeaders: opts.redactHeaders ?? [],
+    redactQueryParams: opts.redactQueryParams ?? [],
+    ignoredUrls: opts.ignoredUrls ?? [],
+    allowedUrls: opts.allowedUrls ?? [],
+    maxBodyBytes: opts.maxBodyBytes ?? DEFAULT_MAX_BODY,
+    ownIngestPrefix: ownIngestHost.replace(/\/$/, "")
+  };
+}
+function isOwnIngest(url, prefix) {
+  return !!prefix && url.startsWith(prefix);
+}
+function urlString(input) {
+  if (typeof input === "string") return input;
+  if (input && typeof input.href === "string") return input.href;
+  if (input && typeof input.url === "string") return input.url;
+  return String(input);
+}
+function safeByteLength(s) {
+  if (s == null) return void 0;
+  if (typeof s === "string") {
+    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 += 1;
+      } else n += 3;
+    }
+    return n;
+  }
+  return void 0;
+}
+function headersToObject(h) {
+  if (!h) return {};
+  if (typeof h.entries === "function") {
+    const out = {};
+    for (const [k, v] of h.entries()) out[String(k).toLowerCase()] = String(v);
+    return out;
+  }
+  if (typeof h === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(h)) {
+      if (v == null) continue;
+      out[String(k).toLowerCase()] = Array.isArray(v) ? v.join(", ") : String(v);
+    }
+    return out;
+  }
+  return {};
+}
+function patchFetch() {
+  const g = globalThis;
+  if (typeof g.fetch !== "function") return;
+  if (g.fetch[FETCH_FLAG2]) return;
+  const original = g.fetch;
+  const wrapped = async function(input, init) {
+    const opts = currentOpts();
+    if (!opts || !currentModule()) {
+      return original.call(this, input, init);
+    }
+    const rawUrl = urlString(input);
+    const sanitizedUrl = redactUrl(rawUrl, opts);
+    const method = (init?.method || input && typeof input === "object" && input.method || "GET").toUpperCase();
+    if (isOwnIngest(rawUrl, opts.ownIngestPrefix) || !shouldCaptureUrl(rawUrl, opts)) {
+      return original.call(this, input, init);
+    }
+    const start = Date.now();
+    const reqHeaders = sanitizeHeaders(headersToObject(init?.headers ?? (input && input.headers)), opts);
+    const reqBody = captureBody(init?.body, opts.captureRequestBody, opts.maxBodyBytes);
+    const reqSize = safeByteLength(typeof init?.body === "string" ? init.body : void 0);
+    let response;
+    try {
+      response = await original.call(this, input, init);
+    } catch (err) {
+      safeCapture({
+        type: "http_request",
+        method,
+        url: sanitizedUrl,
+        statusCode: 0,
+        durationMs: Date.now() - start,
+        requestBody: reqBody,
+        requestHeaders: reqHeaders,
+        requestSize: reqSize,
+        error: String(err?.message ?? err)
+      });
+      throw err;
+    }
+    const durationMs = Date.now() - start;
+    let respBody;
+    let respSize;
+    let respHeaders;
+    try {
+      respHeaders = sanitizeHeaders(headersToObject(response.headers), opts);
+      const lenHeader = typeof response.headers?.get === "function" ? response.headers.get("content-length") : null;
+      if (lenHeader) respSize = parseInt(lenHeader, 10) || void 0;
+      if (opts.captureResponseBody && typeof response.clone === "function") {
+        try {
+          const cloned = response.clone();
+          const text = await cloned.text();
+          respBody = captureBody(text, true, opts.maxBodyBytes);
+          if (respSize == null) respSize = safeByteLength(text);
+        } catch {
+        }
+      }
+    } catch {
+    }
+    safeCapture({
+      type: "http_request",
+      method,
+      url: sanitizedUrl,
+      statusCode: response.status,
+      durationMs,
+      requestBody: reqBody,
+      requestHeaders: reqHeaders,
+      requestSize: reqSize,
+      responseBody: respBody,
+      responseHeaders: respHeaders,
+      responseSize: respSize
+    });
+    return response;
+  };
+  wrapped[FETCH_FLAG2] = true;
+  g.fetch = wrapped;
+}
+function patchXhr() {
+  const g = globalThis;
+  const X = g.XMLHttpRequest;
+  if (!X || X.prototype[XHR_FLAG]) return;
+  const origOpen = X.prototype.open;
+  const origSend = X.prototype.send;
+  const origSetRequestHeader = X.prototype.setRequestHeader;
+  X.prototype.open = function(method, url, ...rest) {
+    this.__allstak_method__ = method;
+    this.__allstak_url__ = url;
+    this.__allstak_headers__ = {};
+    return origOpen.call(this, method, url, ...rest);
+  };
+  X.prototype.setRequestHeader = function(name, value) {
+    try {
+      this.__allstak_headers__[String(name).toLowerCase()] = String(value);
+    } catch {
+    }
+    return origSetRequestHeader.call(this, name, value);
+  };
+  X.prototype.send = function(body) {
+    const opts = currentOpts();
+    if (!opts || !currentModule()) return origSend.call(this, body);
+    const start = Date.now();
+    const method = String(this.__allstak_method__ || "GET").toUpperCase();
+    const rawUrl = String(this.__allstak_url__ || "");
+    const sanitizedUrl = redactUrl(rawUrl, opts);
+    if (isOwnIngest(rawUrl, opts.ownIngestPrefix) || !shouldCaptureUrl(rawUrl, opts)) {
+      return origSend.call(this, body);
+    }
+    const reqHeaders = sanitizeHeaders(this.__allstak_headers__, opts);
+    const reqBody = captureBody(body, opts.captureRequestBody, opts.maxBodyBytes);
+    const reqSize = safeByteLength(typeof body === "string" ? body : void 0);
+    const finish = (statusCode, error) => {
+      const durationMs = Date.now() - start;
+      let respHeaders;
+      let respBody;
+      let respSize;
+      try {
+        const liveOpts = currentOpts() ?? opts;
+        if (liveOpts.captureHeaders && typeof this.getAllResponseHeaders === "function") {
+          const raw = this.getAllResponseHeaders() || "";
+          const dict = {};
+          for (const line of raw.split(/\r?\n/)) {
+            const idx = line.indexOf(":");
+            if (idx > 0) dict[line.slice(0, idx).trim().toLowerCase()] = line.slice(idx + 1).trim();
+          }
+          respHeaders = sanitizeHeaders(dict, liveOpts);
+        }
+        if (liveOpts.captureResponseBody) {
+          const text = this.responseText;
+          if (typeof text === "string") {
+            respBody = captureBody(text, true, liveOpts.maxBodyBytes);
+            respSize = safeByteLength(text);
+          }
+        }
+      } catch {
+      }
+      safeCapture({
+        type: "http_request",
+        method,
+        url: sanitizedUrl,
+        statusCode,
+        durationMs,
+        requestBody: reqBody,
+        requestHeaders: reqHeaders,
+        requestSize: reqSize,
+        responseBody: respBody,
+        responseHeaders: respHeaders,
+        responseSize: respSize,
+        error
+      });
+    };
+    this.addEventListener?.("load", () => finish(this.status || 0));
+    this.addEventListener?.("error", () => finish(0, "network"));
+    this.addEventListener?.("abort", () => finish(0, "abort"));
+    this.addEventListener?.("timeout", () => finish(0, "timeout"));
+    return origSend.call(this, body);
+  };
+  X.prototype[XHR_FLAG] = true;
+}
+function instrumentAxiosInstance(axiosInstance, module2, opts) {
+  if (!axiosInstance || typeof axiosInstance.interceptors !== "object") return axiosInstance;
+  if (axiosInstance[AXIOS_FLAG]) return axiosInstance;
+  axiosInstance[AXIOS_FLAG] = true;
+  const reqStarts = /* @__PURE__ */ new WeakMap();
+  axiosInstance.interceptors.request.use((config) => {
+    try {
+      const rawUrl = (config.baseURL ? config.baseURL.replace(/\/$/, "") : "") + (config.url || "");
+      reqStarts.set(config, {
+        start: Date.now(),
+        method: String(config.method || "GET").toUpperCase(),
+        rawUrl
+      });
+    } catch {
+    }
+    return config;
+  });
+  const finalize = (cfg, statusCode, response, error) => {
+    const meta = reqStarts.get(cfg);
+    if (!meta) return;
+    reqStarts.delete(cfg);
+    if (isOwnIngest(meta.rawUrl, opts.ownIngestPrefix)) return;
+    if (!shouldCaptureUrl(meta.rawUrl, opts)) return;
+    const sanitizedUrl = redactUrl(meta.rawUrl, opts);
+    const reqHeaders = sanitizeHeaders(headersToObject(cfg.headers), opts);
+    const reqBody = captureBody(cfg.data, opts.captureRequestBody, opts.maxBodyBytes);
+    const respHeaders = sanitizeHeaders(headersToObject(response?.headers), opts);
+    const respBody = captureBody(response?.data, opts.captureResponseBody, opts.maxBodyBytes);
+    try {
+      module2.capture({
+        type: "http_request",
+        method: meta.method,
+        url: sanitizedUrl,
+        statusCode,
+        durationMs: Date.now() - meta.start,
+        requestBody: reqBody,
+        requestHeaders: reqHeaders,
+        responseBody: respBody,
+        responseHeaders: respHeaders,
+        error
+      });
+    } catch {
+    }
+  };
+  axiosInstance.interceptors.response.use(
+    (response) => {
+      finalize(response.config, response.status);
+      return response;
+    },
+    (err) => {
+      const cfg = err?.config;
+      const status = err?.response?.status ?? 0;
+      finalize(cfg, status, err?.response, String(err?.message ?? err));
+      throw err;
+    }
+  );
+  return axiosInstance;
+}
+function tryAutoInstrumentAxios(module2, opts) {
+  try {
+    const axios = globalThis.require?.("axios") ?? null;
+    if (axios) instrumentAxiosInstance(axios.default ?? axios, module2, opts);
+  } catch {
+  }
+}
+function installHttpInstrumentation(module2, options, ownIngestHost) {
+  const bound = bind(options, ownIngestHost);
+  _currentModule = module2;
+  _currentOpts = bound;
+  try {
+    patchFetch();
+  } catch {
+  }
+  try {
+    patchXhr();
+  } catch {
+  }
+  try {
+    tryAutoInstrumentAxios(module2, bound);
+  } catch {
+  }
+  return {
+    instrumentAxios: (axios) => instrumentAxiosInstance(axios, module2, bound)
+  };
+}
+
+// src/client.ts
+var INGEST_HOST = "https://api.allstak.sa";
+var SDK_NAME = "allstak-react";
+var SDK_VERSION = "0.3.0";
+var ERRORS_PATH = "/ingest/v1/errors";
+var LOGS_PATH = "/ingest/v1/logs";
+var VALID_BREADCRUMB_TYPES = /* @__PURE__ */ new Set(["http", "log", "ui", "navigation", "query", "default"]);
+var VALID_BREADCRUMB_LEVELS = /* @__PURE__ */ new Set(["info", "warn", "error", "debug"]);
+var DEFAULT_MAX_BREADCRUMBS = 50;
+function frameToString(f) {
+  const fn = f.function && f.function.length > 0 ? f.function : "<anonymous>";
+  const file = f.filename || f.absPath || "<anonymous>";
+  return `    at ${fn} (${file}:${f.lineno ?? 0}:${f.colno ?? 0})`;
+}
+function generateId() {
+  const hex = (n) => Math.floor(Math.random() * n).toString(16).padStart(1, "0");
+  const seg = (len) => Array.from({ length: len }, () => hex(16)).join("");
+  return `${seg(8)}-${seg(4)}-4${seg(3)}-${(8 + Math.floor(Math.random() * 4)).toString(16)}${seg(3)}-${seg(12)}`;
+}
+function browserRequestContext() {
+  if (typeof window === "undefined" || typeof location === "undefined") return void 0;
+  return {
+    method: "GET",
+    path: location.pathname || "/",
+    host: location.host || "",
+    userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0
+  };
+}
+var AllStakClient = class {
+  constructor(config) {
+    this.breadcrumbs = [];
+    this.scopeStack = [];
+    this.replay = null;
+    this.httpRequests = null;
+    this._instrumentAxios = null;
+    this.onErrorHandler = null;
+    this.onRejectionHandler = null;
+    if (!config.apiKey) throw new Error("AllStak: config.apiKey is required");
+    this.config = { ...config };
+    if (!this.config.environment) this.config.environment = "production";
+    if (!this.config.sdkName) this.config.sdkName = SDK_NAME;
+    if (!this.config.sdkVersion) this.config.sdkVersion = SDK_VERSION;
+    if (!this.config.platform) this.config.platform = "browser";
+    this.sessionId = generateId();
+    this.maxBreadcrumbs = config.maxBreadcrumbs ?? DEFAULT_MAX_BREADCRUMBS;
+    const baseUrl = (config.host ?? INGEST_HOST).replace(/\/$/, "");
+    this.transport = new HttpTransport(baseUrl, config.apiKey);
+    this.tracing = new TracingModule(this.transport, {
+      service: config.service ?? config.release ?? "",
+      environment: this.config.environment ?? "production",
+      tracesSampleRate: config.tracesSampleRate
+    });
+    if (config.autoCaptureBrowserErrors !== false && typeof window !== "undefined") {
+      this.installBrowserHandlers();
+    }
+    if (config.autoBreadcrumbsFetch !== false) {
+      try {
+        instrumentFetch(safeAddBreadcrumb, baseUrl);
+      } catch {
+      }
+    }
+    if (config.autoBreadcrumbsConsole !== false) {
+      try {
+        instrumentConsole(safeAddBreadcrumb);
+      } catch {
+      }
+    }
+    if (config.autoBreadcrumbsNavigation !== false) {
+      try {
+        instrumentBrowserNavigation(safeAddBreadcrumb);
+      } catch {
+      }
+    }
+    if (config.replay && (config.replay.enabled ?? true)) {
+      try {
+        this.replay = new ReplayRecorder(this.transport, this.sessionId, safeAddBreadcrumb, config.replay);
+        this.replay.start();
+      } catch {
+      }
+    }
+    if (config.enableHttpTracking) {
+      try {
+        this.httpRequests = new HttpRequestModule(this.transport);
+        this.httpRequests.setDefaults({
+          environment: this.config.environment,
+          release: this.config.release,
+          dist: this.config.dist,
+          platform: this.config.platform,
+          sdkName: this.config.sdkName,
+          sdkVersion: this.config.sdkVersion
+        });
+        const { instrumentAxios } = installHttpInstrumentation(
+          this.httpRequests,
+          config.httpTracking ?? {},
+          baseUrl
+        );
+        this._instrumentAxios = instrumentAxios;
+      } catch {
+      }
+    }
+  }
+  /** Manually instrument an axios instance. No-op when HTTP tracking is off. */
+  instrumentAxios(axios) {
+    if (!this._instrumentAxios) return axios;
+    return this._instrumentAxios(axios);
+  }
+  /** Snapshot of recent failed HTTP requests for error-linking. */
+  getRecentFailedHttp() {
+    return this.httpRequests?.getRecentFailed() ?? [];
+  }
+  captureException(error, context) {
+    if (!this.passesSampleRate()) return;
+    const frames = parseStack(error.stack).map((f) => ({
+      ...f,
+      platform: this.config.platform,
+      debugId: resolveDebugId(f.filename)
+    }));
+    const stackTrace = frames.length > 0 ? frames.map(frameToString) : void 0;
+    const currentBreadcrumbs = this.breadcrumbs.length > 0 ? [...this.breadcrumbs] : void 0;
+    this.breadcrumbs = [];
+    const exceptionClass = (error.name && error.name !== "Error" ? error.name : void 0) || error.constructor?.name || "Error";
+    const eff = this.effective();
+    const traceContext = {};
+    const traceId = this.tracing.getTraceId();
+    if (traceId) traceContext.traceId = traceId;
+    const spanId = this.tracing.getCurrentSpanId();
+    if (spanId) traceContext.spanId = spanId;
+    const recentFailed = this.httpRequests?.getRecentFailed() ?? [];
+    if (recentFailed.length > 0) {
+      traceContext["http.recentFailed"] = recentFailed.map((r) => ({
+        method: r.method,
+        url: r.url,
+        statusCode: r.statusCode,
+        durationMs: r.durationMs,
+        error: r.error
+      }));
+    }
+    const payload = {
+      exceptionClass,
+      message: error.message,
+      stackTrace,
+      frames: frames.length > 0 ? frames : void 0,
+      platform: this.config.platform,
+      sdkName: this.config.sdkName,
+      sdkVersion: this.config.sdkVersion,
+      dist: this.config.dist,
+      level: eff.level ?? "error",
+      environment: this.config.environment,
+      release: this.config.release,
+      sessionId: this.sessionId,
+      user: eff.user,
+      metadata: { ...this.buildMetadata(context), ...traceContext },
+      breadcrumbs: currentBreadcrumbs,
+      requestContext: browserRequestContext(),
+      fingerprint: eff.fingerprint
+    };
+    this.sendThroughBeforeSend(payload);
+  }
+  /** Start a new span — auto-parented to any currently-active span. */
+  startSpan(operation, options) {
+    return this.tracing.startSpan(operation, options);
+  }
+  /** Get (and lazily create) the active trace ID. */
+  getTraceId() {
+    return this.tracing.getTraceId();
+  }
+  /** Override the active trace ID, e.g. from an inbound request header. */
+  setTraceId(traceId) {
+    this.tracing.setTraceId(traceId);
+  }
+  /** ID of the currently-active span, or null. */
+  getCurrentSpanId() {
+    return this.tracing.getCurrentSpanId();
+  }
+  /** Reset the trace ID and the active span stack. */
+  resetTrace() {
+    this.tracing.resetTrace();
+  }
+  captureMessage(message, level = "info", options = {}) {
+    const as = options.as ?? (level === "fatal" || level === "error" ? "both" : "log");
+    if (as === "log" || as === "both") {
+      this.sendLog(level === "warning" ? "warn" : level, message);
+    }
+    if (as === "error" || as === "both") {
+      if (!this.passesSampleRate()) return;
+      const eff = this.effective();
+      const payload = {
+        exceptionClass: "Message",
+        message,
+        platform: this.config.platform,
+        sdkName: this.config.sdkName,
+        sdkVersion: this.config.sdkVersion,
+        dist: this.config.dist,
+        level,
+        environment: this.config.environment,
+        release: this.config.release,
+        sessionId: this.sessionId,
+        user: eff.user,
+        metadata: this.buildMetadata(),
+        requestContext: browserRequestContext(),
+        fingerprint: eff.fingerprint
+      };
+      this.sendThroughBeforeSend(payload);
+    }
+  }
+  addBreadcrumb(type, message, level, data) {
+    const crumb = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      type: VALID_BREADCRUMB_TYPES.has(type) ? type : "default",
+      message,
+      level: level && VALID_BREADCRUMB_LEVELS.has(level) ? level : "info",
+      ...data ? { data } : {}
+    };
+    if (this.breadcrumbs.length >= this.maxBreadcrumbs) this.breadcrumbs.shift();
+    this.breadcrumbs.push(crumb);
+  }
+  clearBreadcrumbs() {
+    this.breadcrumbs = [];
+  }
+  setUser(user) {
+    this.config.user = user;
+  }
+  setTag(key, value) {
+    if (!this.config.tags) this.config.tags = {};
+    this.config.tags[key] = value;
+  }
+  /** Bulk-set tags. Merges with existing tags. */
+  setTags(tags) {
+    if (!this.config.tags) this.config.tags = {};
+    Object.assign(this.config.tags, tags);
+  }
+  /** Set a single extra value. */
+  setExtra(key, value) {
+    if (!this.config.extras) this.config.extras = {};
+    this.config.extras[key] = value;
+  }
+  /** Bulk-set extras. Merges with existing extras. */
+  setExtras(extras) {
+    if (!this.config.extras) this.config.extras = {};
+    Object.assign(this.config.extras, extras);
+  }
+  /**
+   * Attach a named context bag (e.g. `app`, `device`, `runtime`) — appears
+   * under `metadata['context.<name>']` on every subsequent event. Pass
+   * `null` to remove a previously-set context.
+   */
+  setContext(name, ctx) {
+    if (!this.config.contexts) this.config.contexts = {};
+    if (ctx === null) delete this.config.contexts[name];
+    else this.config.contexts[name] = ctx;
+  }
+  /**
+   * Wait for the in-flight retry-buffer to drain. Resolves `true` if the
+   * buffer empties within `timeoutMs` (default 2000ms), `false` otherwise.
+   */
+  flush(timeoutMs) {
+    return this.transport.flush(timeoutMs);
+  }
+  /** Set the default severity level applied to subsequent captures. */
+  setLevel(level) {
+    this.config.level = level;
+  }
+  /**
+   * Set a custom grouping fingerprint applied to subsequent events.
+   * Pass `null` or an empty array to clear and revert to default grouping.
+   */
+  setFingerprint(fingerprint) {
+    this.config.fingerprint = fingerprint && fingerprint.length > 0 ? fingerprint : void 0;
+  }
+  setIdentity(identity) {
+    if (identity.sdkName) this.config.sdkName = identity.sdkName;
+    if (identity.sdkVersion) this.config.sdkVersion = identity.sdkVersion;
+    if (identity.platform) this.config.platform = identity.platform;
+    if (identity.dist) this.config.dist = identity.dist;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getConfig() {
+    return this.config;
+  }
+  destroy() {
+    if (typeof window !== "undefined") {
+      if (this.onErrorHandler) window.removeEventListener("error", this.onErrorHandler);
+      if (this.onRejectionHandler) window.removeEventListener("unhandledrejection", this.onRejectionHandler);
+    }
+    this.onErrorHandler = null;
+    this.onRejectionHandler = null;
+    this.tracing.destroy();
+    if (this.replay) {
+      this.replay.destroy();
+      this.replay = null;
+    }
+    if (this.httpRequests) {
+      this.httpRequests.destroy();
+      this.httpRequests = null;
+    }
+    this._instrumentAxios = null;
+    this.breadcrumbs = [];
+  }
+  installBrowserHandlers() {
+    this.onErrorHandler = (ev) => {
+      const err = ev.error instanceof Error ? ev.error : new Error(ev.message || "Unknown error");
+      this.captureException(err, { source: "window.onerror" });
+    };
+    this.onRejectionHandler = (ev) => {
+      const err = ev.reason instanceof Error ? ev.reason : new Error(String(ev.reason));
+      this.captureException(err, { source: "window.unhandledrejection" });
+    };
+    window.addEventListener("error", this.onErrorHandler);
+    window.addEventListener("unhandledrejection", this.onRejectionHandler);
+  }
+  sendLog(level, message) {
+    this.transport.send(LOGS_PATH, {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message,
+      sessionId: this.sessionId,
+      environment: this.config.environment,
+      release: this.config.release,
+      platform: this.config.platform,
+      sdkName: this.config.sdkName,
+      sdkVersion: this.config.sdkVersion,
+      metadata: { ...this.releaseTags(), ...this.config.tags }
+    });
+  }
+  passesSampleRate() {
+    const r = this.config.sampleRate;
+    if (typeof r !== "number" || r >= 1) return true;
+    if (r <= 0) return false;
+    return Math.random() < r;
+  }
+  /**
+   * Returns the effective config layer = base config + every active scope.
+   * Scope-only overrides (set inside `withScope`) flow into the wire
+   * payload without leaking out of the callback.
+   */
+  effective() {
+    return mergeScopes(this.config, this.scopeStack);
+  }
+  buildMetadata(perCallContext) {
+    const eff = this.effective();
+    const out = {
+      ...this.releaseTags(),
+      ...eff.tags,
+      ...eff.extras ?? {},
+      ...perCallContext ?? {}
+    };
+    if (eff.contexts) {
+      for (const [name, ctx] of Object.entries(eff.contexts)) {
+        out[`context.${name}`] = ctx;
+      }
+    }
+    return out;
+  }
+  /**
+   * Run `callback` with a fresh, temporary {@link Scope} that isolates
+   * any user/tag/extra/context/fingerprint/level it sets. The scope is
+   * popped automatically when the callback returns or throws — including
+   * for `Promise`-returning callbacks (the pop runs in `.finally`).
+   *
+   * Use this on the server (SSR / RSC / API route handlers) to attach
+   * per-request user/tags without leaking that data into another request
+   * being processed concurrently.
+   */
+  withScope(callback) {
+    const scope = new Scope();
+    this.scopeStack.push(scope);
+    let popped = false;
+    const pop = () => {
+      if (!popped) {
+        popped = true;
+        this.scopeStack.pop();
+      }
+    };
+    try {
+      const result = callback(scope);
+      if (result && typeof result.then === "function") {
+        return result.then(
+          (v) => {
+            pop();
+            return v;
+          },
+          (e) => {
+            pop();
+            throw e;
+          }
+        );
+      }
+      pop();
+      return result;
+    } catch (err) {
+      pop();
+      throw err;
+    }
+  }
+  /** Direct access to the topmost active scope, or null. @internal */
+  getCurrentScope() {
+    return this.scopeStack[this.scopeStack.length - 1] ?? null;
+  }
+  async sendThroughBeforeSend(payload) {
+    let final = payload;
+    if (this.config.beforeSend) {
+      try {
+        final = await this.config.beforeSend(payload);
+      } catch {
+        final = payload;
+      }
+    }
+    if (!final) return;
+    this.transport.send(ERRORS_PATH, final);
+  }
+  releaseTags() {
+    const out = {};
+    if (this.config.sdkName) out["sdk.name"] = this.config.sdkName;
+    if (this.config.sdkVersion) out["sdk.version"] = this.config.sdkVersion;
+    if (this.config.platform) out["platform"] = this.config.platform;
+    if (this.config.dist) out["dist"] = this.config.dist;
+    if (this.config.commitSha) out["commit.sha"] = this.config.commitSha;
+    if (this.config.branch) out["commit.branch"] = this.config.branch;
+    return out;
+  }
+};
+var instance = null;
+function ensureInit() {
+  if (!instance) throw new Error("AllStak.init() must be called before using the SDK");
+  return instance;
+}
+function safeAddBreadcrumb(type, message, level, data) {
+  try {
+    instance?.addBreadcrumb(type, message, level, data);
+  } catch {
+  }
+}
+__setDefaultBreadcrumbForwarder(safeAddBreadcrumb);
+var AllStak = {
+  init(config) {
+    if (instance) instance.destroy();
+    instance = new AllStakClient(config);
+    return instance;
+  },
+  captureException(error, context) {
+    ensureInit().captureException(error, context);
+  },
+  captureMessage(message, level = "info", options) {
+    ensureInit().captureMessage(message, level, options);
+  },
+  addBreadcrumb(type, message, level, data) {
+    ensureInit().addBreadcrumb(type, message, level, data);
+  },
+  clearBreadcrumbs() {
+    ensureInit().clearBreadcrumbs();
+  },
+  setUser(user) {
+    ensureInit().setUser(user);
+  },
+  setTag(key, value) {
+    ensureInit().setTag(key, value);
+  },
+  setTags(tags) {
+    ensureInit().setTags(tags);
+  },
+  setExtra(key, value) {
+    ensureInit().setExtra(key, value);
+  },
+  setExtras(extras) {
+    ensureInit().setExtras(extras);
+  },
+  setContext(name, ctx) {
+    ensureInit().setContext(name, ctx);
+  },
+  setLevel(level) {
+    ensureInit().setLevel(level);
+  },
+  setFingerprint(fingerprint) {
+    ensureInit().setFingerprint(fingerprint);
+  },
+  flush(timeoutMs) {
+    return ensureInit().flush(timeoutMs);
+  },
+  setIdentity(identity) {
+    ensureInit().setIdentity(identity);
+  },
+  /**
+   * Run `callback` with a fresh, temporary {@link Scope}. Any user/tag/
+   * extra/context/fingerprint/level set on the scope is visible only inside
+   * the callback. Pop is automatic (sync, async, throwing).
+   */
+  withScope(callback) {
+    return ensureInit().withScope(callback);
+  },
+  startSpan(operation, options) {
+    return ensureInit().startSpan(operation, options);
+  },
+  getTraceId() {
+    return ensureInit().getTraceId();
+  },
+  setTraceId(traceId) {
+    ensureInit().setTraceId(traceId);
+  },
+  getCurrentSpanId() {
+    return ensureInit().getCurrentSpanId();
+  },
+  resetTrace() {
+    ensureInit().resetTrace();
+  },
+  /** Manually instrument an axios instance. No-op when HTTP tracking is off. */
+  instrumentAxios(axios) {
+    return ensureInit().instrumentAxios(axios);
+  },
+  getSessionId() {
+    return ensureInit().getSessionId();
+  },
+  getConfig() {
+    return instance?.getConfig() ?? null;
+  },
+  destroy() {
+    instance?.destroy();
+    instance = null;
+  },
+  /** @internal */
+  _getInstance() {
+    return instance;
+  }
+};
+
+// src/index.ts
+var AllStakErrorBoundary = class extends React.Component {
+  constructor() {
+    super(...arguments);
+    this.state = { error: null };
+    this.reset = () => this.setState({ error: null });
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, info) {
+    try {
+      AllStak.addBreadcrumb("ui", "React error boundary caught error", "error", {
+        componentStack: info.componentStack ?? ""
+      });
+      const context = {
+        componentStack: info.componentStack ?? "",
+        source: "react-error-boundary"
+      };
+      if (this.props.tags) {
+        for (const [k, v] of Object.entries(this.props.tags)) {
+          context[`tag.${k}`] = v;
+        }
+      }
+      AllStak.captureException(error, context);
+    } catch {
+    }
+    try {
+      this.props.onError?.(error, info);
+    } catch {
+    }
+  }
+  render() {
+    if (this.state.error) {
+      const { fallback } = this.props;
+      if (typeof fallback === "function") {
+        return fallback({ error: this.state.error, reset: this.reset });
+      }
+      if (fallback !== void 0) return fallback;
+      return null;
+    }
+    return this.props.children;
+  }
+};
+function useAllStak() {
+  return React.useMemo(
+    () => ({
+      captureException: (error, ctx) => AllStak.captureException(error, ctx),
+      captureMessage: (msg, level = "info") => AllStak.captureMessage(msg, level),
+      setUser: (user) => AllStak.setUser(user),
+      setTag: (key, value) => AllStak.setTag(key, value),
+      addBreadcrumb: (type, message, level, data) => AllStak.addBreadcrumb(type, message, level, data)
+    }),
+    []
+  );
+}
+function withAllStakProfiler(Component2, name) {
+  const displayName = name ?? Component2.displayName ?? Component2.name ?? "AnonymousComponent";
+  const Wrapped = (props) => {
+    React.useEffect(() => {
+      AllStak.addBreadcrumb("navigation", `Mounted <${displayName}>`, "info");
+    }, []);
+    return React.createElement(Component2, props);
+  };
+  Wrapped.displayName = `withAllStakProfiler(${displayName})`;
+  return Wrapped;
+}
 //# sourceMappingURL=index.js.map