@allstak/react 0.1.2 → 0.2.1

package/dist/index.mjs

@@ -1,13 +1,1257 @@
 // src/index.ts
-import {
-  AllStakErrorBoundary,
-  useAllStak,
-  withAllStakProfiler,
-  AllStak
-} from "@allstak/js/react";
+import * as React from "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 isOwnIngest = !!(ownBaseUrl && url.startsWith(ownBaseUrl));
+    const start = Date.now();
+    try {
+      const response = await originalFetch.call(this, input, init);
+      const durationMs = Date.now() - start;
+      if (!isOwnIngest) {
+        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 (!isOwnIngest) {
+        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/client.ts
+var INGEST_HOST = "https://api.allstak.sa";
+var SDK_NAME = "allstak-react";
+var SDK_VERSION = "0.2.1";
+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.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 {
+      }
+    }
+  }
+  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 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;
+    }
+    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();
+  },
+  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;
+}
 export {
   AllStak,
+  AllStakClient,
   AllStakErrorBoundary,
+  INGEST_HOST,
+  ReplayRecorder,
+  SDK_NAME,
+  SDK_VERSION,
+  Scope,
+  instrumentBrowserNavigation,
+  instrumentConsole,
+  instrumentFetch,
+  instrumentNextRouter,
+  instrumentReactRouter,
   useAllStak,
   withAllStakProfiler
 };