@allstak/react-native 0.1.3 → 0.3.0

package/dist/index.mjs

@@ -1,7 +1,1856 @@
+import {
+  __require
+} from "./chunk-BJTO5JO5.mjs";
+
+// 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 before navigation away or during native crash drain.
+   */
+  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/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-surrogate.ts
+var REPLAY_INGEST_PATH = "/ingest/v1/replay";
+var FLUSH_INTERVAL_MS2 = 1e4;
+var ReplaySurrogate = class {
+  constructor(transport, sessionId, options = {}) {
+    this.transport = transport;
+    this.buffer = [];
+    this.flushTimer = null;
+    this.active = false;
+    this.destroyed = false;
+    this.sessionId = sessionId;
+    this.opts = {
+      enabled: options.enabled ?? true,
+      sampleRate: options.sampleRate ?? 0,
+      safeParams: options.safeParams ?? [],
+      maxBufferedEvents: options.maxBufferedEvents ?? 200
+    };
+  }
+  /** Enable recording for this session if sample-rate roll passes. */
+  start() {
+    if (!this.opts.enabled) return false;
+    if (this.active) return true;
+    if (Math.random() >= this.opts.sampleRate) return false;
+    this.active = true;
+    this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS2);
+    return true;
+  }
+  /** Record a screen view. Filters params through the safeParams allow-list. */
+  recordScreenView(routeName, params) {
+    if (!this.active) return;
+    const safe = {};
+    if (params && this.opts.safeParams.length > 0) {
+      for (const key of this.opts.safeParams) {
+        if (key in params) safe[key] = params[key];
+      }
+    }
+    this.push({ ts: Date.now(), k: "screen", data: { route: routeName, params: safe } });
+  }
+  /** Record an AppState transition (foreground/background/inactive). */
+  recordAppState(next) {
+    if (!this.active) return;
+    this.push({ ts: Date.now(), k: "appstate", data: { state: next } });
+  }
+  /** Record a free-form, customer-validated checkpoint. */
+  recordManual(label, data) {
+    if (!this.active) return;
+    this.push({ ts: Date.now(), k: "manual", data: { label, ...data ?? {} } });
+  }
+  destroy() {
+    this.destroyed = true;
+    this.active = false;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flush();
+  }
+  /** @internal — for tests. */
+  isActive() {
+    return this.active;
+  }
+  /** @internal — 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
+    });
+  }
+};
+
+// 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_FLAG = "__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_FLAG]) 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_FLAG] = 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, module, 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 {
+      module.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(module, opts) {
+  try {
+    const axios = globalThis.require?.("axios") ?? null;
+    if (axios) instrumentAxiosInstance(axios.default ?? axios, module, opts);
+  } catch {
+  }
+}
+function installHttpInstrumentation(module, options, ownIngestHost) {
+  const bound = bind(options, ownIngestHost);
+  _currentModule = module;
+  _currentOpts = bound;
+  try {
+    patchFetch();
+  } catch {
+  }
+  try {
+    patchXhr();
+  } catch {
+  }
+  try {
+    tryAutoInstrumentAxios(module, bound);
+  } catch {
+  }
+  return {
+    instrumentAxios: (axios) => instrumentAxiosInstance(axios, module, bound)
+  };
+}
+
+// src/client.ts
+var INGEST_HOST = "https://api.allstak.sa";
+var SDK_NAME = "allstak-react-native";
+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)}`;
+}
+var AllStakClient = class {
+  constructor(config) {
+    this.breadcrumbs = [];
+    this.scopeStack = [];
+    this.replay = null;
+    this.httpRequests = null;
+    this._instrumentAxios = 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 = "react-native";
+    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.replay && (config.replay.enabled ?? true)) {
+      try {
+        this.replay = new ReplaySurrogate(this.transport, this.sessionId, 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 {
+      }
+    }
+  }
+  /** Access the replay surrogate (or null if not initialized / sampled out). */
+  getReplay() {
+    return this.replay;
+  }
+  /** Manually instrument an axios instance. No-op when HTTP tracking is off. */
+  instrumentAxios(axios) {
+    return this._instrumentAxios ? this._instrumentAxios(axios) : axios;
+  }
+  /** Snapshot of recent failed HTTP requests for error-linking. */
+  getRecentFailedHttp() {
+    return this.httpRequests?.getRecentFailed() ?? [];
+  }
+  // ── Public API ────────────────────────────────────────────────────
+  captureException(error, context) {
+    if (!this.passesSampleRate()) return;
+    const frames = parseStack(error.stack).map((f) => ({
+      ...f,
+      platform: this.config.platform
+    }));
+    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,
+      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(),
+        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() {
+    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 = [];
+  }
+  // ── Internal ──────────────────────────────────────────────────────
+  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.buildMetadata()
+    });
+  }
+  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 scope on the
+   * stack. Inner code reads from this instead of `this.config` directly so
+   * 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 to attach per-request context without leaking
+   * across concurrent requests.
+   */
+  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 __safeAddBreadcrumbForInstrumentation(type, message, level, data) {
+  try {
+    instance?.addBreadcrumb(type, message, level, data);
+  } catch {
+  }
+}
+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 scoped context. Any user/tag/extra/context/
+   * fingerprint/level set on the passed `Scope` is visible only inside the
+   * callback (and any captures made within it). Pop is automatic, including
+   * for async callbacks and thrown errors.
+   */
+  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();
+  },
+  /** Access the privacy-first replay surrogate (or null if disabled / sampled out). */
+  getReplay() {
+    return ensureInit().getReplay();
+  },
+  /** 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 — exposed for testing */
+  _getInstance() {
+    return instance;
+  }
+};
+
+// src/auto-breadcrumbs.ts
+var FETCH_FLAG2 = "__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_FLAG2]) 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_FLAG2] = 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/architecture.ts
+function detectArchitecture() {
+  const g = globalThis;
+  const newArchitecture = typeof g.__turboModuleProxy !== "undefined";
+  const bridgeless = typeof g.RN$Bridgeless !== "undefined" && !!g.RN$Bridgeless;
+  const hermes = typeof g.HermesInternal !== "undefined";
+  let tag = "unknown";
+  if (newArchitecture) tag = "new-arch";
+  else if (typeof g.nativeFlushQueueImmediate === "function") tag = "old-arch";
+  return { newArchitecture, bridgeless, hermes, tag };
+}
+function applyArchitectureTags(setTag) {
+  const info = detectArchitecture();
+  try {
+    setTag("rn.architecture", info.tag);
+    setTag("rn.bridgeless", String(info.bridgeless));
+    setTag("rn.hermes", String(info.hermes));
+  } catch {
+  }
+  return info;
+}
+
+// src/navigation.ts
+var NAV_FLAG = /* @__PURE__ */ Symbol.for("allstak.nav.subscribed");
+var LINKING_FLAG = "__allstak_linking_patched__";
+function instrumentReactNavigation(navigationRef, options = {}) {
+  if (!navigationRef || typeof navigationRef.addListener !== "function") {
+    return () => {
+    };
+  }
+  const ref = navigationRef;
+  if (ref[NAV_FLAG]) return () => {
+  };
+  ref[NAV_FLAG] = true;
+  const safeKeys = options.safeParams ?? [];
+  const forwardToReplay = options.forwardToReplay !== false;
+  const filterParams = (params) => {
+    const out = {};
+    if (!params) return out;
+    for (const key of safeKeys) if (key in params) out[key] = params[key];
+    return out;
+  };
+  let last = navigationRef.getCurrentRoute?.()?.name;
+  const unsub = navigationRef.addListener("state", () => {
+    const route = navigationRef.getCurrentRoute?.();
+    const next = route?.name;
+    if (!next || next === last) return;
+    const safe = filterParams(route?.params);
+    try {
+      AllStak.addBreadcrumb(
+        "navigation",
+        `${last ?? "<start>"} -> ${next}`,
+        "info",
+        { from: last, to: next, params: safe }
+      );
+    } catch {
+    }
+    if (forwardToReplay) {
+      try {
+        const replay = AllStak.getReplay?.();
+        replay?.recordScreenView?.(next, route?.params);
+      } catch {
+      }
+    }
+    last = next;
+  });
+  return () => {
+    try {
+      unsub?.();
+    } catch {
+    }
+    ref[NAV_FLAG] = false;
+  };
+}
+function instrumentNavigationFromLinking() {
+  try {
+    const rn = __require("react-native");
+    const Linking = rn?.Linking;
+    if (!Linking || typeof Linking.addEventListener !== "function") return;
+    if (Linking[LINKING_FLAG]) return;
+    Linking.addEventListener("url", (ev) => {
+      const url = typeof ev?.url === "string" ? ev.url : "";
+      if (!url) return;
+      try {
+        AllStak.addBreadcrumb("navigation", `deep-link: ${url.split("?")[0]}`, "info", { url });
+      } catch {
+      }
+    });
+    Linking[LINKING_FLAG] = true;
+  } catch {
+  }
+}
+
 // src/index.ts
-import { installReactNative, AllStak } from "@allstak/js/react-native";
+function instrumentXmlHttpRequest() {
+  const flag = "__allstak_xhr_patched__";
+  const X = globalThis.XMLHttpRequest;
+  if (!X || X.prototype[flag]) return;
+  const ownHost = (() => {
+    try {
+      const cfg = AllStak.getConfig();
+      return (cfg?.host ?? "https://api.allstak.sa").replace(/\/$/, "");
+    } catch {
+      return "";
+    }
+  })();
+  const origOpen = X.prototype.open;
+  const origSend = X.prototype.send;
+  X.prototype.open = function(method, url, ...rest) {
+    this.__allstak_method__ = method;
+    this.__allstak_url__ = url;
+    return origOpen.call(this, method, url, ...rest);
+  };
+  X.prototype.send = function(body) {
+    const start = Date.now();
+    const method = this.__allstak_method__ || "GET";
+    const url = this.__allstak_url__ || "";
+    const isOwnIngest2 = ownHost && url.startsWith(ownHost);
+    let path = url;
+    try {
+      path = new URL(url).pathname;
+    } catch {
+    }
+    const onDone = (status) => {
+      const durationMs = Date.now() - start;
+      try {
+        AllStak.addBreadcrumb(
+          "http",
+          `${method} ${path} -> ${status}`,
+          status >= 400 ? "error" : "info",
+          { method, url: path, statusCode: status, durationMs }
+        );
+      } catch {
+      }
+    };
+    if (!isOwnIngest2) {
+      this.addEventListener?.("load", () => onDone(this.status || 0));
+      this.addEventListener?.("error", () => onDone(0));
+      this.addEventListener?.("abort", () => onDone(0));
+      this.addEventListener?.("timeout", () => onDone(0));
+    }
+    return origSend.call(this, body);
+  };
+  X.prototype[flag] = true;
+}
+var __testNativeModule = null;
+function __setNativeModuleForTest(mod) {
+  __testNativeModule = mod;
+}
+async function drainPendingNativeCrashes(release) {
+  try {
+    let native = __testNativeModule;
+    if (!native) {
+      const rn = __require("react-native");
+      native = rn?.NativeModules?.AllStakNative;
+    }
+    if (!native) return;
+    if (typeof native.install === "function") {
+      try {
+        await native.install(release ?? "");
+      } catch {
+      }
+    }
+    if (typeof native.drainPendingCrash === "function") {
+      const json = await native.drainPendingCrash();
+      if (json && json !== "") {
+        try {
+          const payload = JSON.parse(json);
+          const err = new Error(payload?.message ?? "Native crash");
+          err.name = payload?.exceptionClass ?? "NativeCrash";
+          err.stack = Array.isArray(payload?.stackTrace) ? payload.stackTrace.join("\n") : String(payload?.stackTrace ?? "");
+          AllStak.captureException(err, {
+            ...payload?.metadata || {},
+            "native.crash": "true"
+          });
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+function installReactNative(options = {}) {
+  const autoError = options.autoErrorHandler !== false;
+  const autoPromise = options.autoPromiseRejections !== false;
+  const autoDevice = options.autoDeviceTags !== false;
+  const autoAppState = options.autoAppStateBreadcrumbs !== false;
+  const autoNetwork = options.autoNetworkCapture !== false;
+  AllStak.setTag("platform", "react-native");
+  try {
+    applyArchitectureTags((k, v) => AllStak.setTag(k, v));
+  } catch {
+  }
+  try {
+    const hermes = typeof globalThis.HermesInternal !== "undefined";
+    let dist;
+    try {
+      const rn = __require("react-native");
+      const os = rn?.Platform?.OS;
+      if (os === "ios" || os === "android") {
+        dist = `${os}-${hermes ? "hermes" : "jsc"}`;
+      }
+    } catch {
+    }
+    AllStak.setIdentity({
+      sdkName: "allstak-react-native",
+      sdkVersion: "0.3.0",
+      platform: "react-native",
+      dist
+    });
+  } catch {
+  }
+  if (autoNetwork) {
+    try {
+      instrumentXmlHttpRequest();
+    } catch {
+    }
+  }
+  if (options.autoFetchBreadcrumbs !== false) {
+    try {
+      const cfg = AllStak.getConfig();
+      const ownBaseUrl = (cfg?.host ?? "https://api.allstak.sa").replace(/\/$/, "");
+      instrumentFetch(__safeAddBreadcrumbForInstrumentation, ownBaseUrl);
+    } catch {
+    }
+  }
+  if (options.autoConsoleBreadcrumbs !== false) {
+    try {
+      instrumentConsole(__safeAddBreadcrumbForInstrumentation);
+    } catch {
+    }
+  }
+  if (autoDevice) {
+    try {
+      const rn = __require("react-native");
+      const Platform = rn?.Platform;
+      if (Platform) {
+        AllStak.setTag("device.os", String(Platform.OS ?? ""));
+        AllStak.setTag("device.osVersion", String(Platform.Version ?? ""));
+        if (Platform.constants?.Model) {
+          AllStak.setTag("device.model", String(Platform.constants.Model));
+        }
+      }
+    } catch {
+    }
+  }
+  if (autoAppState) {
+    try {
+      const rn = __require("react-native");
+      const AppState = rn?.AppState;
+      if (AppState && typeof AppState.addEventListener === "function") {
+        AppState.addEventListener("change", (next) => {
+          try {
+            AllStak.addBreadcrumb("navigation", `AppState \u2192 ${next}`, "info", { appState: next });
+          } catch {
+          }
+        });
+      }
+    } catch {
+    }
+  }
+  if (autoError) {
+    const eu = globalThis.ErrorUtils;
+    if (eu && typeof eu.setGlobalHandler === "function") {
+      const prev = eu.getGlobalHandler();
+      eu.setGlobalHandler((error, isFatal) => {
+        try {
+          AllStak.captureException(error, {
+            source: "react-native-ErrorUtils",
+            fatal: String(Boolean(isFatal))
+          });
+        } catch {
+        }
+        try {
+          prev(error, isFatal);
+        } catch {
+        }
+      });
+    }
+  }
+  if (autoPromise) {
+    try {
+      const tracking = __require("promise/setimmediate/rejection-tracking");
+      tracking.enable({
+        allRejections: true,
+        onUnhandled: (_id, rejection) => {
+          const err = rejection instanceof Error ? rejection : new Error(`Unhandled promise rejection: ${String(rejection)}`);
+          try {
+            AllStak.captureException(err, { source: "unhandledRejection" });
+          } catch {
+          }
+        },
+        onHandled: () => {
+        }
+      });
+    } catch {
+      const g = globalThis;
+      if (typeof g.addEventListener === "function") {
+        g.addEventListener("unhandledrejection", (ev) => {
+          const reason = ev?.reason;
+          const err = reason instanceof Error ? reason : new Error(String(reason));
+          try {
+            AllStak.captureException(err, { source: "unhandledRejection" });
+          } catch {
+          }
+        });
+      }
+    }
+  }
+}
 export {
   AllStak,
-  installReactNative
+  AllStakClient,
+  HttpRequestModule,
+  INGEST_HOST,
+  ReplaySurrogate,
+  SDK_NAME,
+  SDK_VERSION,
+  Scope,
+  __setNativeModuleForTest,
+  applyArchitectureTags,
+  detectArchitecture,
+  drainPendingNativeCrashes,
+  installReactNative,
+  instrumentNavigationFromLinking,
+  instrumentReactNavigation
 };
 //# sourceMappingURL=index.mjs.map