@allstak/react-native 0.3.0 → 0.3.2

package/dist/index.mjs

@@ -3,28 +3,57 @@ import {
 } from "./chunk-BJTO5JO5.mjs";
 
 // src/transport.ts
-var REQUEST_TIMEOUT = 3e3;
+var REQUEST_TIMEOUT = 2e3;
 var MAX_BUFFER = 100;
+var FAILURE_THRESHOLD = 3;
+var BACKOFF_BASE_MS = 500;
+var BACKOFF_MAX_MS = 3e4;
 var HttpTransport = class {
-  constructor(baseUrl, apiKey) {
+  constructor(baseUrl, apiKey, enabled = true) {
     this.baseUrl = baseUrl;
     this.apiKey = apiKey;
+    this.enabled = enabled;
     this.buffer = [];
     this.flushing = false;
+    this.consecutiveFailures = 0;
+    this.circuitOpenUntil = 0;
+    this.sent = 0;
+    this.failed = 0;
+    this.dropped = 0;
+  }
+  send(path, payload) {
+    if (!this.enabled) {
+      this.noteDropped();
+      return Promise.resolve();
+    }
+    this.enqueueOrDispatch({ path, payload });
+    return Promise.resolve();
+  }
+  enqueueOrDispatch(item) {
+    if (Date.now() < this.circuitOpenUntil) {
+      this.push(item);
+      return;
+    }
+    void this.dispatch(item).catch(() => void 0);
   }
-  async send(path, payload) {
+  async dispatch(item) {
     try {
-      await this.doFetch(path, payload);
-      await this.flushBuffer();
-    } catch {
-      if (this.buffer.length >= MAX_BUFFER) this.buffer.shift();
-      this.buffer.push({ path, payload });
+      await this.doFetch(item.path, item.payload);
+      this.sent++;
+      this.consecutiveFailures = 0;
+      this.circuitOpenUntil = 0;
+      this.scheduleFlush();
+    } catch (err) {
+      this.failed++;
+      this.recordFailure(err);
+      this.push(item);
     }
   }
   async doFetch(path, payload) {
     const url = `${this.baseUrl}${path}`;
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), REQUEST_TIMEOUT);
+    const started = Date.now();
     try {
       const res = await fetch(url, {
         method: "POST",
@@ -38,26 +67,77 @@ var HttpTransport = class {
       if (!res.ok) throw new Error(`HTTP ${res.status}`);
     } finally {
       clearTimeout(timeoutId);
+      this.lastTransportLatencyMs = Date.now() - started;
     }
   }
+  push(item) {
+    if (this.buffer.length >= MAX_BUFFER) {
+      this.buffer.shift();
+      this.dropped++;
+    }
+    this.buffer.push(item);
+  }
+  scheduleFlush() {
+    if (this.flushing || this.buffer.length === 0) return;
+    const delay = Math.max(0, this.circuitOpenUntil - Date.now());
+    const timer = setTimeout(() => {
+      void this.flushBuffer().catch(() => void 0);
+    }, delay);
+    if (typeof timer === "object" && typeof timer.unref === "function") timer.unref();
+  }
   async flushBuffer() {
     if (this.flushing || this.buffer.length === 0) return;
     this.flushing = true;
+    const started = Date.now();
     try {
       const items = this.buffer.splice(0, this.buffer.length);
       for (const item of items) {
+        if (Date.now() < this.circuitOpenUntil) {
+          this.push(item);
+          continue;
+        }
         try {
           await this.doFetch(item.path, item.payload);
-        } catch {
+          this.sent++;
+          this.consecutiveFailures = 0;
+          this.circuitOpenUntil = 0;
+        } catch (err) {
+          this.failed++;
+          this.recordFailure(err);
+          this.push(item);
         }
       }
     } finally {
+      this.lastFlushDurationMs = Date.now() - started;
       this.flushing = false;
+      if (this.buffer.length > 0) this.scheduleFlush();
     }
   }
+  recordFailure(error) {
+    this.consecutiveFailures++;
+    if (this.consecutiveFailures < FAILURE_THRESHOLD) return;
+    const retryAfterMs = retryAfterFromError(error);
+    const backoff = retryAfterMs ?? jitteredBackoff(this.consecutiveFailures);
+    this.circuitOpenUntil = Date.now() + backoff;
+  }
   getBufferSize() {
     return this.buffer.length;
   }
+  noteDropped(count = 1) {
+    this.dropped += Math.max(0, count);
+  }
+  getStats() {
+    return {
+      queued: this.buffer.length,
+      sent: this.sent,
+      failed: this.failed,
+      dropped: this.dropped,
+      consecutiveFailures: this.consecutiveFailures,
+      circuitOpenUntil: this.circuitOpenUntil,
+      lastTransportLatencyMs: this.lastTransportLatencyMs,
+      lastFlushDurationMs: this.lastFlushDurationMs
+    };
+  }
   /**
    * Wait for the in-flight retry-buffer to drain. Resolves `true` if the
    * buffer empties within `timeoutMs` (default 2000ms), `false` otherwise.
@@ -74,6 +154,14 @@ var HttpTransport = class {
     return true;
   }
 };
+function jitteredBackoff(failures) {
+  const exp = Math.min(BACKOFF_MAX_MS, BACKOFF_BASE_MS * 2 ** Math.min(8, failures - FAILURE_THRESHOLD));
+  return Math.floor(exp / 2 + Math.random() * (exp / 2));
+}
+function retryAfterFromError(error) {
+  const message = error instanceof Error ? error.message : "";
+  return /HTTP\s+(429|503)/.test(message) ? BACKOFF_MAX_MS : null;
+}
 
 // src/stack.ts
 var V8_FRAME_RE = /^\s*at\s+(?:(.+?)\s+\()?((?:.+?):(\d+):(\d+))\)?\s*$/;
@@ -128,6 +216,24 @@ function isInApp(filename) {
   return true;
 }
 
+// src/utils/debug-id.ts
+var REGISTRY_KEY = "_allstakDebugIds";
+var cache = /* @__PURE__ */ new Map();
+function resolveDebugId(filename) {
+  if (!filename) return void 0;
+  if (cache.has(filename)) return cache.get(filename) ?? void 0;
+  const registry = globalThis[REGISTRY_KEY];
+  if (registry && typeof registry === "object") {
+    const hit = registry[filename];
+    if (typeof hit === "string" && hit.length > 0) {
+      cache.set(filename, hit);
+      return hit;
+    }
+  }
+  cache.set(filename, null);
+  return void 0;
+}
+
 // src/scope.ts
 var Scope = class {
   constructor() {
@@ -339,6 +445,7 @@ var TracingModule = class {
     }
     if (!this.flushTimer) {
       this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS);
+      this.flushTimer?.unref?.();
     }
   }
   flush() {
@@ -384,10 +491,11 @@ var ReplaySurrogate = class {
     if (Math.random() >= this.opts.sampleRate) return false;
     this.active = true;
     this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS2);
+    this.flushTimer?.unref?.();
     return true;
   }
   /** Record a screen view. Filters params through the safeParams allow-list. */
-  recordScreenView(routeName, params) {
+  recordScreenView(routeName, params, context) {
     if (!this.active) return;
     const safe = {};
     if (params && this.opts.safeParams.length > 0) {
@@ -395,17 +503,22 @@ var ReplaySurrogate = class {
         if (key in params) safe[key] = params[key];
       }
     }
-    this.push({ ts: Date.now(), k: "screen", data: { route: routeName, params: safe } });
+    this.push({ ts: Date.now(), k: "screen", data: { route: routeName, params: safe, ...compact(context) } });
   }
   /** Record an AppState transition (foreground/background/inactive). */
-  recordAppState(next) {
+  recordAppState(next, context) {
     if (!this.active) return;
-    this.push({ ts: Date.now(), k: "appstate", data: { state: next } });
+    this.push({ ts: Date.now(), k: "appstate", data: { state: next, ...compact(context) } });
   }
   /** Record a free-form, customer-validated checkpoint. */
-  recordManual(label, data) {
+  recordManual(label, data, context) {
+    if (!this.active) return;
+    this.push({ ts: Date.now(), k: "manual", data: { label, ...data ?? {}, ...compact(context) } });
+  }
+  /** Record a forensic mobile session timeline marker. This is not replay. */
+  recordTimelineMarker(kind, label, data, context) {
     if (!this.active) return;
-    this.push({ ts: Date.now(), k: "manual", data: { label, ...data ?? {} } });
+    this.push({ ts: Date.now(), k: kind, data: { label, ...data ?? {}, ...compact(context) } });
   }
   destroy() {
     this.destroyed = true;
@@ -439,6 +552,14 @@ var ReplaySurrogate = class {
     });
   }
 };
+function compact(context) {
+  if (!context) return {};
+  const out = {};
+  for (const [key, value] of Object.entries(context)) {
+    if (value !== void 0 && value !== null && value !== "") out[key] = value;
+  }
+  return out;
+}
 
 // src/http-requests.ts
 var INGEST_PATH = "/ingest/v1/http-requests";
@@ -450,6 +571,12 @@ function genTraceId() {
   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 genRequestId() {
+  return genTraceId();
+}
+function generateHttpId() {
+  return genTraceId();
+}
 function splitHostPath(url) {
   try {
     const u = new URL(url);
@@ -476,6 +603,7 @@ var HttpRequestModule = class {
     const item = {
       type: "http_request",
       traceId: ev.traceId ?? genTraceId(),
+      requestId: ev.requestId ?? genRequestId(),
       direction: "outbound",
       method: (ev.method || "GET").toUpperCase(),
       host,
@@ -490,6 +618,16 @@ var HttpRequestModule = class {
       requestHeaders: ev.requestHeaders,
       responseHeaders: ev.responseHeaders,
       error: ev.error,
+      spanId: ev.spanId,
+      parentSpanId: ev.parentSpanId,
+      requestBodyStatus: ev.requestBodyStatus,
+      responseBodyStatus: ev.responseBodyStatus,
+      requestBodyRedactedFields: ev.requestBodyRedactedFields,
+      responseBodyRedactedFields: ev.responseBodyRedactedFields,
+      requestBodyTruncated: ev.requestBodyTruncated,
+      responseBodyTruncated: ev.responseBodyTruncated,
+      capturePolicy: ev.capturePolicy,
+      linkConfidence: ev.linkConfidence ?? "exact",
       environment: this.defaults.environment,
       release: this.defaults.release,
       dist: this.defaults.dist,
@@ -508,7 +646,10 @@ var HttpRequestModule = class {
       this.flush();
       return;
     }
-    if (!this.flushTimer) this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS3);
+    if (!this.flushTimer) {
+      this.flushTimer = setInterval(() => this.flush(), FLUSH_INTERVAL_MS3);
+      this.flushTimer?.unref?.();
+    }
   }
   /** Snapshot of the last failed requests for error-linking. Newest last. */
   getRecentFailed() {
@@ -560,6 +701,24 @@ var ALWAYS_REDACT_QUERY = /* @__PURE__ */ new Set([
   "jwt"
 ]);
 var REDACTED = "[REDACTED]";
+var DEFAULT_REDACT_BODY_FIELDS = [
+  "password",
+  "passcode",
+  "otp",
+  "token",
+  "authorization",
+  "cookie",
+  "session",
+  "refresh_token",
+  "access_token",
+  "jwt",
+  "card",
+  "credit_card",
+  "iban",
+  "national_id",
+  "secret",
+  "api_key"
+];
 function shouldCaptureUrl(url, opts) {
   if (!url) return false;
   const lower = url.toLowerCase();
@@ -627,25 +786,125 @@ function sanitizeHeaders(headers, opts) {
   }
   return out;
 }
-function captureBody(body, enabled, maxBodyBytes) {
-  if (!enabled) return void 0;
-  if (body == null) return void 0;
+function captureBodyResult(body, enabled, maxBodyBytes, opts = {}, contentType) {
+  if (!enabled) {
+    return {
+      status: "disabled",
+      redactedFields: [],
+      truncated: false,
+      capturePolicy: "body_capture_disabled"
+    };
+  }
+  if (body == null) {
+    return {
+      status: "empty",
+      redactedFields: [],
+      truncated: false,
+      capturePolicy: "empty_body"
+    };
+  }
+  const allowed = opts.allowedContentTypes ?? ["application/json", "text/", "application/problem+json"];
+  if (contentType && !allowed.some((needle) => contentType.toLowerCase().includes(needle.toLowerCase()))) {
+    return {
+      status: "unsupported",
+      redactedFields: [],
+      truncated: false,
+      capturePolicy: `unsupported_content_type:${contentType}`
+    };
+  }
   let str;
+  let redactedFields = [];
   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>";
+    if (tag !== "[object Object]" && tag !== "[object Array]") {
+      return {
+        body: "<binary>",
+        status: "unsupported",
+        redactedFields: [],
+        truncated: false,
+        capturePolicy: "unsupported_binary_body"
+      };
+    }
+    const redacted = redactJsonValue(body, opts);
+    redactedFields = redacted.redactedFields;
     try {
-      str = JSON.stringify(body);
+      str = JSON.stringify(redacted.value);
     } catch {
-      return "<unserializable>";
+      return {
+        body: "<unserializable>",
+        status: "unsupported",
+        redactedFields,
+        truncated: false,
+        capturePolicy: "unserializable_body"
+      };
     }
   } else {
-    return "<binary>";
+    return {
+      body: "<binary>",
+      status: "unsupported",
+      redactedFields: [],
+      truncated: false,
+      capturePolicy: "unsupported_body_type"
+    };
+  }
+  if (typeof body === "string" && looksJson(contentType, str)) {
+    try {
+      const redacted = redactJsonValue(JSON.parse(str), opts);
+      redactedFields = redacted.redactedFields;
+      str = JSON.stringify(redacted.value);
+    } catch {
+      str = redactSensitiveText(str, opts);
+    }
+  }
+  let truncated = false;
+  if (str.length > maxBodyBytes) {
+    str = str.slice(0, maxBodyBytes) + "\u2026[truncated]";
+    truncated = true;
   }
-  if (str.length > maxBodyBytes) return str.slice(0, maxBodyBytes) + "\u2026[truncated]";
-  return str;
+  return {
+    body: str,
+    status: truncated ? "truncated" : redactedFields.length > 0 ? "redacted" : "captured",
+    redactedFields: Array.from(new Set(redactedFields)).sort(),
+    truncated,
+    capturePolicy: "opt_in_body_capture"
+  };
+}
+function looksJson(contentType, body) {
+  if (contentType && contentType.toLowerCase().includes("json")) return true;
+  const trimmed = body.trim();
+  return trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]");
+}
+function redactJsonValue(value, opts, path = "") {
+  const fieldSet = new Set([...DEFAULT_REDACT_BODY_FIELDS, ...opts.redactBodyFields ?? []].map((v) => v.toLowerCase()));
+  const redactedFields = [];
+  const walk = (input, currentPath) => {
+    if (Array.isArray(input)) return input.map((item, index) => walk(item, `${currentPath}[${index}]`));
+    if (!input || typeof input !== "object") return input;
+    const out = {};
+    for (const [key, raw] of Object.entries(input)) {
+      const keyLower = key.toLowerCase();
+      const nextPath = currentPath ? `${currentPath}.${key}` : key;
+      if (fieldSet.has(keyLower) || keyLower.includes("token") || keyLower.includes("password")) {
+        out[key] = REDACTED;
+        redactedFields.push(nextPath);
+      } else {
+        out[key] = walk(raw, nextPath);
+      }
+    }
+    return out;
+  };
+  return { value: walk(value, path), redactedFields };
+}
+function redactSensitiveText(input, opts) {
+  const fields = [...DEFAULT_REDACT_BODY_FIELDS, ...opts.redactBodyFields ?? []];
+  let out = input;
+  for (const key of fields) {
+    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    out = out.replace(new RegExp(`("${escaped}"\\s*:\\s*)"[^"]*"`, "gi"), `$1"${REDACTED}"`);
+  }
+  return out;
 }
 
 // src/http-instrumentation.ts
@@ -655,12 +914,16 @@ var AXIOS_FLAG = /* @__PURE__ */ Symbol.for("allstak.http.axios.instrumented");
 var DEFAULT_MAX_BODY = 4096;
 var _currentModule = null;
 var _currentOpts = null;
+var _currentRuntime = null;
 function currentModule() {
   return _currentModule;
 }
 function currentOpts() {
   return _currentOpts;
 }
+function currentRuntime() {
+  return _currentRuntime;
+}
 function safeCapture(ev) {
   try {
     currentModule()?.capture(ev);
@@ -677,6 +940,8 @@ function bind(opts, ownIngestHost) {
     ignoredUrls: opts.ignoredUrls ?? [],
     allowedUrls: opts.allowedUrls ?? [],
     maxBodyBytes: opts.maxBodyBytes ?? DEFAULT_MAX_BODY,
+    allowedContentTypes: opts.allowedContentTypes ?? ["application/json", "text/", "application/problem+json"],
+    redactBodyFields: opts.redactBodyFields ?? [],
     ownIngestPrefix: ownIngestHost.replace(/\/$/, "")
   };
 }
@@ -723,6 +988,77 @@ function headersToObject(h) {
   }
   return {};
 }
+function normalizeTraceId(traceId) {
+  const hex = traceId.replace(/[^a-fA-F0-9]/g, "").toLowerCase();
+  return (hex + "00000000000000000000000000000000").slice(0, 32);
+}
+function normalizeSpanId(spanId) {
+  const hex = spanId.replace(/[^a-fA-F0-9]/g, "").toLowerCase();
+  return (hex + "0000000000000000").slice(0, 16);
+}
+function createRequestContext(method, url) {
+  const runtime = currentRuntime();
+  if (!runtime) return null;
+  const requestId = generateHttpId();
+  const parentSpanId = runtime.tracing.getCurrentSpanId() ?? "";
+  const span = runtime.tracing.startSpan("mobile.http", {
+    description: `${method.toUpperCase()} ${url}`,
+    tags: { requestId, method: method.toUpperCase(), platform: runtime.platform ?? "react-native" }
+  });
+  const traceId = runtime.tracing.getTraceId();
+  const spanId = span.spanId;
+  return {
+    traceId,
+    requestId,
+    spanId,
+    parentSpanId,
+    traceparent: `00-${normalizeTraceId(traceId)}-${normalizeSpanId(spanId)}-01`,
+    span
+  };
+}
+function propagationHeaders(ctx) {
+  const headers = {
+    traceparent: ctx.traceparent,
+    "x-allstak-trace-id": ctx.traceId,
+    "x-allstak-request-id": ctx.requestId
+  };
+  if (ctx.parentSpanId) headers["x-allstak-parent-span-id"] = ctx.parentSpanId;
+  return headers;
+}
+function mergeHeaders(headers, propagation) {
+  const entries = Object.entries(propagation);
+  if (typeof Headers !== "undefined" && headers instanceof Headers) {
+    const next2 = new Headers(headers);
+    for (const [k, v] of entries) if (!next2.has(k)) next2.set(k, v);
+    return next2;
+  }
+  if (Array.isArray(headers)) {
+    const existing = new Set(headers.map(([k]) => String(k).toLowerCase()));
+    const next2 = [...headers];
+    for (const [k, v] of entries) if (!existing.has(k.toLowerCase())) next2.push([k, v]);
+    return next2;
+  }
+  const next = { ...headers ?? {} };
+  const lower = new Set(Object.keys(next).map((k) => k.toLowerCase()));
+  for (const [k, v] of entries) if (!lower.has(k.toLowerCase())) next[k] = v;
+  return next;
+}
+function injectFetchHeaders(input, init, ctx) {
+  const headers = mergeHeaders(init?.headers ?? (input && typeof input === "object" ? input.headers : void 0), propagationHeaders(ctx));
+  return { input, init: { ...init ?? {}, headers } };
+}
+function recordTimeline(kind, label, ctx, data) {
+  try {
+    currentRuntime()?.replay?.recordTimelineMarker?.(kind, label, data, {
+      traceId: ctx.traceId,
+      requestId: ctx.requestId,
+      spanId: ctx.spanId,
+      release: currentRuntime()?.release,
+      dist: currentRuntime()?.dist
+    });
+  } catch {
+  }
+}
 function patchFetch() {
   const g = globalThis;
   if (typeof g.fetch !== "function") return;
@@ -740,23 +1076,37 @@ function patchFetch() {
       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 ctx = createRequestContext(method, sanitizedUrl);
+    const requestInit = ctx ? injectFetchHeaders(input, init, ctx).init : init;
+    if (ctx) recordTimeline("request", "request_started", ctx, { method, url: sanitizedUrl });
+    const reqHeaders = sanitizeHeaders(headersToObject(requestInit?.headers ?? (input && input.headers)), opts);
+    const reqBody = captureBodyResult(requestInit?.body, opts.captureRequestBody, opts.maxBodyBytes, opts, reqHeaders?.["content-type"]);
     const reqSize = safeByteLength(typeof init?.body === "string" ? init.body : void 0);
     let response;
     try {
-      response = await original.call(this, input, init);
+      response = await original.call(this, input, requestInit);
     } catch (err) {
+      ctx?.span.finish("error");
+      if (ctx) recordTimeline("exception", "request_failed", ctx, { method, url: sanitizedUrl, error: String(err?.message ?? err) });
       safeCapture({
         type: "http_request",
+        traceId: ctx?.traceId ?? generateHttpId(),
+        requestId: ctx?.requestId ?? generateHttpId(),
+        spanId: ctx?.spanId,
+        parentSpanId: ctx?.parentSpanId,
         method,
         url: sanitizedUrl,
         statusCode: 0,
         durationMs: Date.now() - start,
-        requestBody: reqBody,
+        requestBody: reqBody.body,
         requestHeaders: reqHeaders,
         requestSize: reqSize,
-        error: String(err?.message ?? err)
+        requestBodyStatus: reqBody.status,
+        requestBodyRedactedFields: reqBody.redactedFields,
+        requestBodyTruncated: reqBody.truncated,
+        capturePolicy: reqBody.capturePolicy,
+        error: String(err?.message ?? err),
+        linkConfidence: "exact"
       });
       throw err;
     }
@@ -772,25 +1122,41 @@ function patchFetch() {
         try {
           const cloned = response.clone();
           const text = await cloned.text();
-          respBody = captureBody(text, true, opts.maxBodyBytes);
+          respBody = captureBodyResult(text, true, opts.maxBodyBytes, opts, respHeaders?.["content-type"]).body;
           if (respSize == null) respSize = safeByteLength(text);
         } catch {
         }
       }
     } catch {
     }
+    const respBodyResult = captureBodyResult(respBody, opts.captureResponseBody && respBody !== void 0, opts.maxBodyBytes, opts, respHeaders?.["content-type"]);
+    const isError = response.status >= 400;
+    ctx?.span.setTag("requestId", ctx.requestId).setTag("http.status_code", String(response.status)).finish(isError ? "error" : "ok");
+    if (ctx) recordTimeline(isError ? "exception" : "response", isError ? "request_failed" : "response_received", ctx, { statusCode: response.status, durationMs });
     safeCapture({
       type: "http_request",
+      traceId: ctx?.traceId ?? generateHttpId(),
+      requestId: ctx?.requestId ?? generateHttpId(),
+      spanId: ctx?.spanId,
+      parentSpanId: ctx?.parentSpanId,
       method,
       url: sanitizedUrl,
       statusCode: response.status,
       durationMs,
-      requestBody: reqBody,
+      requestBody: reqBody.body,
       requestHeaders: reqHeaders,
       requestSize: reqSize,
-      responseBody: respBody,
+      responseBody: respBodyResult.body,
       responseHeaders: respHeaders,
-      responseSize: respSize
+      responseSize: respSize,
+      requestBodyStatus: reqBody.status,
+      responseBodyStatus: respBodyResult.status,
+      requestBodyRedactedFields: reqBody.redactedFields,
+      responseBodyRedactedFields: respBodyResult.redactedFields,
+      requestBodyTruncated: reqBody.truncated,
+      responseBodyTruncated: respBodyResult.truncated,
+      capturePolicy: `${reqBody.capturePolicy};${respBodyResult.capturePolicy}`,
+      linkConfidence: "exact"
     });
     return response;
   };
@@ -828,7 +1194,17 @@ function patchXhr() {
       return origSend.call(this, body);
     }
     const reqHeaders = sanitizeHeaders(this.__allstak_headers__, opts);
-    const reqBody = captureBody(body, opts.captureRequestBody, opts.maxBodyBytes);
+    const ctx = createRequestContext(method, sanitizedUrl);
+    if (ctx) {
+      for (const [k, v] of Object.entries(propagationHeaders(ctx))) {
+        try {
+          origSetRequestHeader.call(this, k, v);
+        } catch {
+        }
+      }
+      recordTimeline("request", "request_started", ctx, { method, url: sanitizedUrl });
+    }
+    const reqBody = captureBodyResult(body, opts.captureRequestBody, opts.maxBodyBytes, opts, reqHeaders?.["content-type"]);
     const reqSize = safeByteLength(typeof body === "string" ? body : void 0);
     const finish = (statusCode, error) => {
       const durationMs = Date.now() - start;
@@ -846,28 +1222,43 @@ function patchXhr() {
           }
           respHeaders = sanitizeHeaders(dict, liveOpts);
         }
+        let respBodyResult = captureBodyResult(void 0, false, liveOpts.maxBodyBytes, liveOpts);
         if (liveOpts.captureResponseBody) {
           const text = this.responseText;
           if (typeof text === "string") {
-            respBody = captureBody(text, true, liveOpts.maxBodyBytes);
+            respBodyResult = captureBodyResult(text, true, liveOpts.maxBodyBytes, liveOpts, respHeaders?.["content-type"]);
+            respBody = respBodyResult.body;
             respSize = safeByteLength(text);
           }
         }
       } catch {
       }
+      const failed = !!error || statusCode >= 400;
+      ctx?.span.setTag("requestId", ctx.requestId).setTag("http.status_code", String(statusCode)).finish(failed ? "error" : "ok");
+      if (ctx) recordTimeline(failed ? "exception" : "response", failed ? "request_failed" : "response_received", ctx, { statusCode, durationMs, error });
       safeCapture({
         type: "http_request",
+        traceId: ctx?.traceId ?? generateHttpId(),
+        requestId: ctx?.requestId ?? generateHttpId(),
+        spanId: ctx?.spanId,
+        parentSpanId: ctx?.parentSpanId,
         method,
         url: sanitizedUrl,
         statusCode,
         durationMs,
-        requestBody: reqBody,
+        requestBody: reqBody.body,
         requestHeaders: reqHeaders,
         requestSize: reqSize,
         responseBody: respBody,
         responseHeaders: respHeaders,
         responseSize: respSize,
-        error
+        requestBodyStatus: reqBody.status,
+        responseBodyStatus: respBody ? "captured" : opts.captureResponseBody ? "empty" : "disabled",
+        requestBodyRedactedFields: reqBody.redactedFields,
+        requestBodyTruncated: reqBody.truncated,
+        capturePolicy: reqBody.capturePolicy,
+        error,
+        linkConfidence: "exact"
       });
     };
     this.addEventListener?.("load", () => finish(this.status || 0));
@@ -886,10 +1277,17 @@ function instrumentAxiosInstance(axiosInstance, module, opts) {
   axiosInstance.interceptors.request.use((config) => {
     try {
       const rawUrl = (config.baseURL ? config.baseURL.replace(/\/$/, "") : "") + (config.url || "");
+      const method = String(config.method || "GET").toUpperCase();
+      const ctx = createRequestContext(method, rawUrl);
+      if (ctx) {
+        config.headers = mergeHeaders(config.headers, propagationHeaders(ctx));
+        recordTimeline("request", "request_started", ctx, { method, url: rawUrl });
+      }
       reqStarts.set(config, {
         start: Date.now(),
-        method: String(config.method || "GET").toUpperCase(),
-        rawUrl
+        method,
+        rawUrl,
+        ctx
       });
     } catch {
     }
@@ -903,21 +1301,36 @@ function instrumentAxiosInstance(axiosInstance, module, opts) {
     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 reqBody = captureBodyResult(cfg.data, opts.captureRequestBody, opts.maxBodyBytes, opts, reqHeaders?.["content-type"]);
     const respHeaders = sanitizeHeaders(headersToObject(response?.headers), opts);
-    const respBody = captureBody(response?.data, opts.captureResponseBody, opts.maxBodyBytes);
+    const respBody = captureBodyResult(response?.data, opts.captureResponseBody, opts.maxBodyBytes, opts, respHeaders?.["content-type"]);
+    const failed = !!error || statusCode >= 400;
+    meta.ctx?.span.setTag("requestId", meta.ctx.requestId).setTag("http.status_code", String(statusCode)).finish(failed ? "error" : "ok");
+    if (meta.ctx) recordTimeline(failed ? "exception" : "response", failed ? "request_failed" : "response_received", meta.ctx, { statusCode, error });
     try {
       module.capture({
         type: "http_request",
+        traceId: meta.ctx?.traceId ?? generateHttpId(),
+        requestId: meta.ctx?.requestId ?? generateHttpId(),
+        spanId: meta.ctx?.spanId,
+        parentSpanId: meta.ctx?.parentSpanId,
         method: meta.method,
         url: sanitizedUrl,
         statusCode,
         durationMs: Date.now() - meta.start,
-        requestBody: reqBody,
+        requestBody: reqBody.body,
         requestHeaders: reqHeaders,
-        responseBody: respBody,
+        responseBody: respBody.body,
         responseHeaders: respHeaders,
-        error
+        requestBodyStatus: reqBody.status,
+        responseBodyStatus: respBody.status,
+        requestBodyRedactedFields: reqBody.redactedFields,
+        responseBodyRedactedFields: respBody.redactedFields,
+        requestBodyTruncated: reqBody.truncated,
+        responseBodyTruncated: respBody.truncated,
+        capturePolicy: `${reqBody.capturePolicy};${respBody.capturePolicy}`,
+        error,
+        linkConfidence: "exact"
       });
     } catch {
     }
@@ -943,10 +1356,11 @@ function tryAutoInstrumentAxios(module, opts) {
   } catch {
   }
 }
-function installHttpInstrumentation(module, options, ownIngestHost) {
+function installHttpInstrumentation(module, options, ownIngestHost, runtime) {
   const bound = bind(options, ownIngestHost);
   _currentModule = module;
   _currentOpts = bound;
+  _currentRuntime = runtime;
   try {
     patchFetch();
   } catch {
@@ -963,11 +1377,16 @@ function installHttpInstrumentation(module, options, ownIngestHost) {
     instrumentAxios: (axios) => instrumentAxiosInstance(axios, module, bound)
   };
 }
+function unbindHttpInstrumentation() {
+  _currentModule = null;
+  _currentOpts = null;
+  _currentRuntime = null;
+}
 
 // src/client.ts
 var INGEST_HOST = "https://api.allstak.sa";
 var SDK_NAME = "allstak-react-native";
-var SDK_VERSION = "0.3.0";
+var SDK_VERSION = "0.3.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"]);
@@ -983,6 +1402,17 @@ function generateId() {
   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 stringContextValue(context, key) {
+  const value = context[key];
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function firstRecentRequestId(recentFailed) {
+  for (let i = recentFailed.length - 1; i >= 0; i--) {
+    const requestId = recentFailed[i]?.requestId;
+    if (requestId && requestId.trim().length > 0) return requestId;
+  }
+  return void 0;
+}
 var AllStakClient = class {
   constructor(config) {
     this.breadcrumbs = [];
@@ -990,9 +1420,6 @@ var AllStakClient = class {
     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;
@@ -1001,7 +1428,7 @@ var AllStakClient = class {
     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.transport = new HttpTransport(baseUrl, config.apiKey ?? "", Boolean(config.apiKey));
     this.tracing = new TracingModule(this.transport, {
       service: config.service ?? config.release ?? "",
       environment: this.config.environment ?? "production",
@@ -1028,7 +1455,15 @@ var AllStakClient = class {
         const { instrumentAxios } = installHttpInstrumentation(
           this.httpRequests,
           config.httpTracking ?? {},
-          baseUrl
+          baseUrl,
+          {
+            tracing: this.tracing,
+            replay: this.replay,
+            release: this.config.release,
+            dist: this.config.dist,
+            platform: this.config.platform,
+            environment: this.config.environment
+          }
         );
         this._instrumentAxios = instrumentAxios;
       } catch {
@@ -1052,33 +1487,67 @@ var AllStakClient = class {
     if (!this.passesSampleRate()) return;
     const frames = parseStack(error.stack).map((f) => ({
       ...f,
-      platform: this.config.platform
+      platform: this.config.platform,
+      debugId: resolveDebugId(f.filename)
     }));
+    const debugIdSet = /* @__PURE__ */ new Set();
+    for (const f of frames) if (f.debugId) debugIdSet.add(f.debugId);
+    const debugMeta = debugIdSet.size > 0 ? { images: Array.from(debugIdSet).map((id2) => ({ type: "sourcemap", debugId: id2 })) } : void 0;
     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();
+    const recentFailed = this.httpRequests?.getRecentFailed() ?? [];
+    const linkedRequest = recentFailed.length > 0 ? recentFailed[recentFailed.length - 1] : void 0;
+    if (linkedRequest?.traceId) this.tracing.setTraceId(linkedRequest.traceId);
+    const exceptionSpan = linkedRequest ? this.tracing.startSpan("mobile.exception", {
+      description: error.message,
+      tags: {
+        requestId: linkedRequest.requestId,
+        exceptionClass
+      }
+    }) : null;
+    exceptionSpan?.finish("error");
+    const traceId = linkedRequest?.traceId ?? this.tracing.getTraceId();
     if (traceId) traceContext.traceId = traceId;
-    const spanId = this.tracing.getCurrentSpanId();
+    const spanId = exceptionSpan?.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
+        error: r.error,
+        requestId: r.requestId,
+        traceId: r.traceId,
+        confidence: r.requestId === linkedRequest?.requestId ? "inferred" : "weak"
       }));
+      traceContext["http.linkConfidence"] = "inferred";
+    }
+    try {
+      if (!linkedRequest) throw new Error("no linked request");
+      this.replay?.recordTimelineMarker?.("exception", "exception_captured", {
+        exceptionClass,
+        message: error.message,
+        requestLinkConfidence: linkedRequest ? "inferred" : "none"
+      }, {
+        traceId,
+        requestId: linkedRequest?.requestId,
+        spanId: spanId ?? void 0,
+        release: this.config.release,
+        dist: this.config.dist
+      });
+    } catch {
     }
     const payload = {
       exceptionClass,
       message: error.message,
       stackTrace,
       frames: frames.length > 0 ? frames : void 0,
+      debugMeta,
       platform: this.config.platform,
       sdkName: this.config.sdkName,
       sdkVersion: this.config.sdkVersion,
@@ -1087,12 +1556,29 @@ var AllStakClient = class {
       environment: this.config.environment,
       release: this.config.release,
       sessionId: this.sessionId,
+      traceId: stringContextValue(traceContext, "traceId"),
+      spanId: stringContextValue(traceContext, "spanId"),
+      requestId: linkedRequest?.requestId ?? firstRecentRequestId(recentFailed),
+      service: this.config.service,
       user: eff.user,
       metadata: { ...this.buildMetadata(context), ...traceContext },
       breadcrumbs: currentBreadcrumbs,
       fingerprint: eff.fingerprint
     };
-    this.sendThroughBeforeSend(payload);
+    if (this.shouldCaptureScreenshot()) {
+      void this.withScreenshotMetadata(error, payload).then((enriched) => this.sendThroughBeforeSend(enriched)).catch(() => this.sendThroughBeforeSend({
+        ...payload,
+        metadata: { ...payload.metadata ?? {}, "screenshot.status": "failed" }
+      }));
+      return;
+    }
+    this.sendThroughBeforeSend({
+      ...payload,
+      metadata: {
+        ...payload.metadata ?? {},
+        "screenshot.status": this.config.screenshot?.enabled ? "unsupported" : "disabled"
+      }
+    });
   }
   /** Start a new span. Auto-parented to any currently-active span. */
   startSpan(operation, options) {
@@ -1133,6 +1619,9 @@ var AllStakClient = class {
         environment: this.config.environment,
         release: this.config.release,
         sessionId: this.sessionId,
+        traceId: this.tracing.getTraceId(),
+        spanId: this.tracing.getCurrentSpanId() ?? void 0,
+        service: this.config.service,
         user: eff.user,
         metadata: this.buildMetadata(),
         fingerprint: eff.fingerprint
@@ -1216,6 +1705,9 @@ var AllStakClient = class {
   getConfig() {
     return this.config;
   }
+  getTransportStats() {
+    return this.transport.getStats();
+  }
   destroy() {
     this.tracing.destroy();
     if (this.replay) {
@@ -1226,6 +1718,7 @@ var AllStakClient = class {
       this.httpRequests.destroy();
       this.httpRequests = null;
     }
+    unbindHttpInstrumentation();
     this._instrumentAxios = null;
     this.breadcrumbs = [];
   }
@@ -1244,6 +1737,58 @@ var AllStakClient = class {
       metadata: this.buildMetadata()
     });
   }
+  shouldCaptureScreenshot() {
+    const screenshot = this.config.screenshot;
+    if (!screenshot?.enabled || screenshot.captureOnError === false || !screenshot.provider) return false;
+    const sampleRate = screenshot.sampleRate ?? 1;
+    return !(sampleRate <= 0 || sampleRate < 1 && Math.random() >= sampleRate);
+  }
+  async withScreenshotMetadata(error, payload) {
+    const screenshot = this.config.screenshot;
+    if (!screenshot?.provider) {
+      return { ...payload, metadata: { ...payload.metadata ?? {}, "screenshot.status": "unsupported" } };
+    }
+    const timeoutMs = Math.max(100, Math.min(screenshot.timeoutMs ?? 1500, 5e3));
+    const maxBytes = Math.max(1024, screenshot.maxBytes ?? 2e5);
+    try {
+      const artifact = await Promise.race([
+        Promise.resolve(screenshot.provider({
+          type: "error",
+          error,
+          traceId: payload.traceId,
+          requestId: payload.requestId
+        })),
+        new Promise((resolve) => setTimeout(() => resolve(null), timeoutMs))
+      ]);
+      if (!artifact) {
+        return { ...payload, metadata: { ...payload.metadata ?? {}, "screenshot.status": "timeout_or_empty" } };
+      }
+      const size = artifact.sizeBytes ?? byteSize(artifact.data);
+      if (size > maxBytes) {
+        this.transport.noteDropped();
+        return {
+          ...payload,
+          metadata: { ...payload.metadata ?? {}, "screenshot.status": "dropped_too_large", "screenshot.sizeBytes": size }
+        };
+      }
+      return {
+        ...payload,
+        metadata: {
+          ...payload.metadata ?? {},
+          "screenshot.status": "captured",
+          "screenshot.contentType": artifact.contentType,
+          "screenshot.width": artifact.width,
+          "screenshot.height": artifact.height,
+          "screenshot.sizeBytes": size,
+          "screenshot.redacted": artifact.redacted ?? false,
+          "screenshot.redactionStrategy": artifact.redactionStrategy,
+          ...artifact.data ? { "screenshot.data": artifact.data } : {}
+        }
+      };
+    } catch {
+      return { ...payload, metadata: { ...payload.metadata ?? {}, "screenshot.status": "failed" } };
+    }
+  }
   passesSampleRate() {
     const r = this.config.sampleRate;
     if (typeof r !== "number" || r >= 1) return true;
@@ -1342,10 +1887,22 @@ var AllStakClient = class {
   }
 };
 var instance = null;
-function ensureInit() {
-  if (!instance) throw new Error("AllStak.init() must be called before using the SDK");
+function maybeInit() {
   return instance;
 }
+function noopSpan(operation = "") {
+  return new Span("", "", "", operation, "", "", "", {}, () => void 0);
+}
+function emptyStats() {
+  return {
+    queued: 0,
+    sent: 0,
+    failed: 0,
+    dropped: 0,
+    consecutiveFailures: 0,
+    circuitOpenUntil: 0
+  };
+}
 function __safeAddBreadcrumbForInstrumentation(type, message, level, data) {
   try {
     instance?.addBreadcrumb(type, message, level, data);
@@ -1354,51 +1911,99 @@ function __safeAddBreadcrumbForInstrumentation(type, message, level, data) {
 }
 var AllStak = {
   init(config) {
-    if (instance) instance.destroy();
-    instance = new AllStakClient(config);
-    return instance;
+    try {
+      if (instance) instance.destroy();
+      instance = new AllStakClient(config);
+      return instance;
+    } catch {
+      instance = new AllStakClient({ ...config, apiKey: "" });
+      return instance;
+    }
   },
   captureException(error, context) {
-    ensureInit().captureException(error, context);
+    try {
+      maybeInit()?.captureException(error, context);
+    } catch {
+    }
   },
   captureMessage(message, level = "info", options) {
-    ensureInit().captureMessage(message, level, options);
+    try {
+      maybeInit()?.captureMessage(message, level, options);
+    } catch {
+    }
   },
   addBreadcrumb(type, message, level, data) {
-    ensureInit().addBreadcrumb(type, message, level, data);
+    try {
+      maybeInit()?.addBreadcrumb(type, message, level, data);
+    } catch {
+    }
   },
   clearBreadcrumbs() {
-    ensureInit().clearBreadcrumbs();
+    try {
+      maybeInit()?.clearBreadcrumbs();
+    } catch {
+    }
   },
   setUser(user) {
-    ensureInit().setUser(user);
+    try {
+      maybeInit()?.setUser(user);
+    } catch {
+    }
   },
   setTag(key, value) {
-    ensureInit().setTag(key, value);
+    try {
+      maybeInit()?.setTag(key, value);
+    } catch {
+    }
   },
   setTags(tags) {
-    ensureInit().setTags(tags);
+    try {
+      maybeInit()?.setTags(tags);
+    } catch {
+    }
   },
   setExtra(key, value) {
-    ensureInit().setExtra(key, value);
+    try {
+      maybeInit()?.setExtra(key, value);
+    } catch {
+    }
   },
   setExtras(extras) {
-    ensureInit().setExtras(extras);
+    try {
+      maybeInit()?.setExtras(extras);
+    } catch {
+    }
   },
   setContext(name, ctx) {
-    ensureInit().setContext(name, ctx);
+    try {
+      maybeInit()?.setContext(name, ctx);
+    } catch {
+    }
   },
   setLevel(level) {
-    ensureInit().setLevel(level);
+    try {
+      maybeInit()?.setLevel(level);
+    } catch {
+    }
   },
   setFingerprint(fingerprint) {
-    ensureInit().setFingerprint(fingerprint);
+    try {
+      maybeInit()?.setFingerprint(fingerprint);
+    } catch {
+    }
   },
   flush(timeoutMs) {
-    return ensureInit().flush(timeoutMs);
+    try {
+      return maybeInit()?.flush(timeoutMs) ?? Promise.resolve(true);
+    } catch {
+      return Promise.resolve(false);
+    }
   },
   setIdentity(identity) {
-    ensureInit().setIdentity(identity);
+    try {
+      maybeInit()?.setIdentity(identity);
+    } catch {
+    }
   },
   /**
    * Run `callback` with a fresh scoped context. Any user/tag/extra/context/
@@ -1407,37 +2012,79 @@ var AllStak = {
    * for async callbacks and thrown errors.
    */
   withScope(callback) {
-    return ensureInit().withScope(callback);
+    try {
+      const client = maybeInit();
+      return client ? client.withScope(callback) : callback(new Scope());
+    } catch {
+      return callback(new Scope());
+    }
   },
   startSpan(operation, options) {
-    return ensureInit().startSpan(operation, options);
+    try {
+      return maybeInit()?.startSpan(operation, options) ?? noopSpan(operation);
+    } catch {
+      return noopSpan(operation);
+    }
   },
   getTraceId() {
-    return ensureInit().getTraceId();
+    try {
+      return maybeInit()?.getTraceId() ?? "";
+    } catch {
+      return "";
+    }
   },
   setTraceId(traceId) {
-    ensureInit().setTraceId(traceId);
+    try {
+      maybeInit()?.setTraceId(traceId);
+    } catch {
+    }
   },
   getCurrentSpanId() {
-    return ensureInit().getCurrentSpanId();
+    try {
+      return maybeInit()?.getCurrentSpanId() ?? null;
+    } catch {
+      return null;
+    }
   },
   resetTrace() {
-    ensureInit().resetTrace();
+    try {
+      maybeInit()?.resetTrace();
+    } catch {
+    }
   },
   /** Access the privacy-first replay surrogate (or null if disabled / sampled out). */
   getReplay() {
-    return ensureInit().getReplay();
+    try {
+      return maybeInit()?.getReplay() ?? null;
+    } catch {
+      return null;
+    }
   },
   /** Manually instrument an axios instance. No-op when HTTP tracking is off. */
   instrumentAxios(axios) {
-    return ensureInit().instrumentAxios(axios);
+    try {
+      return maybeInit()?.instrumentAxios(axios) ?? axios;
+    } catch {
+      return axios;
+    }
   },
   getSessionId() {
-    return ensureInit().getSessionId();
+    try {
+      return maybeInit()?.getSessionId() ?? "";
+    } catch {
+      return "";
+    }
   },
   getConfig() {
     return instance?.getConfig() ?? null;
   },
+  getTransportStats() {
+    try {
+      return maybeInit()?.getTransportStats() ?? emptyStats();
+    } catch {
+      return emptyStats();
+    }
+  },
   destroy() {
     instance?.destroy();
     instance = null;
@@ -1447,6 +2094,17 @@ var AllStak = {
     return instance;
   }
 };
+function byteSize(value) {
+  if (!value) return 0;
+  try {
+    if (typeof TextEncoder !== "undefined") return new TextEncoder().encode(value).length;
+  } catch {
+  }
+  return value.length;
+}
+
+// src/provider.tsx
+import * as React from "react";
 
 // src/auto-breadcrumbs.ts
 var FETCH_FLAG2 = "__allstak_fetch_patched__";
@@ -1494,36 +2152,92 @@ function instrumentFetch(addBreadcrumb, ownBaseUrl) {
   wrapped[FETCH_FLAG2] = true;
   g.fetch = wrapped;
 }
-function instrumentConsole(addBreadcrumb) {
+var CONSOLE_DEFAULTS = {
+  log: false,
+  info: false,
+  warn: true,
+  error: true
+};
+var CONSOLE_METHOD_TO_LEVEL = {
+  log: "info",
+  info: "info",
+  warn: "warn",
+  error: "error"
+};
+var MAX_ARG_BYTES = 5e3;
+function instrumentConsole(addBreadcrumb, options = {}) {
   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);
+  const opts = {
+    log: options.log ?? CONSOLE_DEFAULTS.log,
+    info: options.info ?? CONSOLE_DEFAULTS.info,
+    warn: options.warn ?? CONSOLE_DEFAULTS.warn,
+    error: options.error ?? CONSOLE_DEFAULTS.error
   };
-  console.error = function(...args) {
-    try {
-      addBreadcrumb("log", args.map(safeString).join(" "), "error");
-    } catch {
-    }
-    return origError.apply(console, args);
+  const wrap = (method) => {
+    const orig = console[method];
+    if (typeof orig !== "function") return;
+    const level = CONSOLE_METHOD_TO_LEVEL[method];
+    console[method] = function(...args) {
+      if (opts[method]) {
+        try {
+          const serialized = args.map(safeStringifyArg);
+          const message = truncate(serialized.join(" "));
+          addBreadcrumb("log", message, level, {
+            category: "console",
+            method,
+            args: serialized
+          });
+        } catch {
+        }
+      }
+      return orig.apply(console, args);
+    };
   };
+  if (opts.log) wrap("log");
+  if (opts.info) wrap("info");
+  if (opts.warn) wrap("warn");
+  if (opts.error) wrap("error");
   console[CONSOLE_FLAG] = true;
 }
-function safeString(v) {
-  if (v == null) return String(v);
+function __resetConsoleInstrumentationFlagForTest() {
+  if (typeof console !== "undefined") {
+    delete console[CONSOLE_FLAG];
+  }
+}
+function safeStringifyArg(v) {
+  if (v === null || v === void 0) 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);
+  if (typeof v === "number" || typeof v === "boolean" || typeof v === "bigint") return String(v);
+  if (typeof v === "symbol") return v.toString();
+  if (typeof v === "function") return `[Function${v.name ? ` ${v.name}` : ""}]`;
+  if (v instanceof Error) {
+    return `${v.name || "Error"}: ${v.message}${v.stack ? `
+${v.stack}` : ""}`;
+  }
+  if (typeof v === "object") {
+    try {
+      const seen = /* @__PURE__ */ new WeakSet();
+      const out = JSON.stringify(v, (_key, val) => {
+        if (typeof val === "object" && val !== null) {
+          if (seen.has(val)) return "[Circular]";
+          seen.add(val);
+        }
+        if (typeof val === "bigint") return val.toString();
+        if (typeof val === "function") return `[Function${val.name ? ` ${val.name}` : ""}]`;
+        if (typeof val === "symbol") return val.toString();
+        return val;
+      });
+      return out ?? Object.prototype.toString.call(v);
+    } catch {
+      return Object.prototype.toString.call(v);
+    }
   }
+  return String(v);
+}
+function truncate(s) {
+  if (s.length <= MAX_ARG_BYTES) return s;
+  return s.slice(0, MAX_ARG_BYTES) + "\u2026[truncated]";
 }
 
 // src/architecture.ts
@@ -1551,6 +2265,7 @@ function applyArchitectureTags(setTag) {
 // src/navigation.ts
 var NAV_FLAG = /* @__PURE__ */ Symbol.for("allstak.nav.subscribed");
 var LINKING_FLAG = "__allstak_linking_patched__";
+var NAV_AUTO_PATCH_FLAG = /* @__PURE__ */ Symbol.for("allstak.nav.autoPatched");
 function instrumentReactNavigation(navigationRef, options = {}) {
   if (!navigationRef || typeof navigationRef.addListener !== "function") {
     return () => {
@@ -1602,7 +2317,7 @@ function instrumentReactNavigation(navigationRef, options = {}) {
 }
 function instrumentNavigationFromLinking() {
   try {
-    const rn = __require("react-native");
+    const rn = require("react-native");
     const Linking = rn?.Linking;
     if (!Linking || typeof Linking.addEventListener !== "function") return;
     if (Linking[LINKING_FLAG]) return;
@@ -1618,8 +2333,59 @@ function instrumentNavigationFromLinking() {
   } catch {
   }
 }
+function tryAutoInstrumentNavigation() {
+  const g = globalThis;
+  const isMetro = typeof g.__METRO_GLOBAL_PREFIX__ !== "undefined" || typeof g.__r === "function" || typeof g.HermesInternal !== "undefined";
+  if (isMetro) return false;
+  try {
+    const rnav = require("@react-navigation/native");
+    if (!rnav || !rnav.NavigationContainer) return false;
+    if (rnav[NAV_AUTO_PATCH_FLAG]) return true;
+    const React2 = require("react");
+    if (!React2 || typeof React2.forwardRef !== "function") return false;
+    const OrigContainer = rnav.NavigationContainer;
+    const Wrapped = React2.forwardRef(function AllStakNavigationContainer(props, userRef) {
+      const internalRef = React2.useRef(null);
+      const setRef = React2.useCallback((r) => {
+        internalRef.current = r;
+        if (typeof userRef === "function") userRef(r);
+        else if (userRef) userRef.current = r;
+      }, [userRef]);
+      React2.useEffect(() => {
+        if (internalRef.current) {
+          try {
+            instrumentReactNavigation(internalRef.current);
+          } catch {
+          }
+        }
+      }, []);
+      return React2.createElement(OrigContainer, { ...props, ref: setRef });
+    });
+    Wrapped.displayName = "AllStakNavigationContainer";
+    try {
+      Object.defineProperty(rnav, "NavigationContainer", {
+        value: Wrapped,
+        configurable: true,
+        writable: true
+      });
+      rnav[NAV_AUTO_PATCH_FLAG] = true;
+      return true;
+    } catch {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}
+function __resetAutoNavigationFlagForTest() {
+  try {
+    const rnav = require("@react-navigation/native");
+    if (rnav) delete rnav[NAV_AUTO_PATCH_FLAG];
+  } catch {
+  }
+}
 
-// src/index.ts
+// src/install.ts
 function instrumentXmlHttpRequest() {
   const flag = "__allstak_xhr_patched__";
   const X = globalThis.XMLHttpRequest;
@@ -1671,43 +2437,6 @@ function instrumentXmlHttpRequest() {
   };
   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;
@@ -1723,7 +2452,7 @@ function installReactNative(options = {}) {
     const hermes = typeof globalThis.HermesInternal !== "undefined";
     let dist;
     try {
-      const rn = __require("react-native");
+      const rn = require("react-native");
       const os = rn?.Platform?.OS;
       if (os === "ios" || os === "android") {
         dist = `${os}-${hermes ? "hermes" : "jsc"}`;
@@ -1732,7 +2461,7 @@ function installReactNative(options = {}) {
     }
     AllStak.setIdentity({
       sdkName: "allstak-react-native",
-      sdkVersion: "0.3.0",
+      sdkVersion: SDK_VERSION,
       platform: "react-native",
       dist
     });
@@ -1754,13 +2483,25 @@ function installReactNative(options = {}) {
   }
   if (options.autoConsoleBreadcrumbs !== false) {
     try {
-      instrumentConsole(__safeAddBreadcrumbForInstrumentation);
+      const cfg = AllStak.getConfig();
+      instrumentConsole(__safeAddBreadcrumbForInstrumentation, cfg?.captureConsole);
     } catch {
     }
   }
+  if (options.autoNavigationBreadcrumbs !== false) {
+    let navResult = false;
+    try {
+      navResult = tryAutoInstrumentNavigation();
+    } catch {
+    }
+    if (options.debugLogs) {
+      if (navResult) console.log("[AllStak] Navigation auto-instrumentation enabled");
+      else console.log("[AllStak] Navigation auto-instrumentation not applied; use instrumentReactNavigation(ref) fallback");
+    }
+  }
   if (autoDevice) {
     try {
-      const rn = __require("react-native");
+      const rn = require("react-native");
       const Platform = rn?.Platform;
       if (Platform) {
         AllStak.setTag("device.os", String(Platform.OS ?? ""));
@@ -1774,7 +2515,7 @@ function installReactNative(options = {}) {
   }
   if (autoAppState) {
     try {
-      const rn = __require("react-native");
+      const rn = require("react-native");
       const AppState = rn?.AppState;
       if (AppState && typeof AppState.addEventListener === "function") {
         AppState.addEventListener("change", (next) => {
@@ -1807,17 +2548,30 @@ function installReactNative(options = {}) {
     }
   }
   if (autoPromise) {
+    const wrapTrackerReason = (rejection) => rejection instanceof Error ? rejection : new Error(`Unhandled promise rejection: ${String(rejection)}`);
+    const ship = (err) => {
+      try {
+        AllStak.captureException(err, { source: "unhandledRejection" });
+      } catch {
+      }
+    };
+    try {
+      const hermesInternal = globalThis.HermesInternal;
+      if (hermesInternal && typeof hermesInternal.enablePromiseRejectionTracker === "function") {
+        hermesInternal.enablePromiseRejectionTracker({
+          allRejections: true,
+          onUnhandled: (_id, rejection) => ship(wrapTrackerReason(rejection)),
+          onHandled: () => {
+          }
+        });
+      }
+    } catch {
+    }
     try {
-      const tracking = __require("promise/setimmediate/rejection-tracking");
+      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 {
-          }
-        },
+        onUnhandled: (_id, rejection) => ship(wrapTrackerReason(rejection)),
         onHandled: () => {
         }
       });
@@ -1827,30 +2581,237 @@ function installReactNative(options = {}) {
         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 {
-          }
+          ship(err);
         });
       }
     }
   }
 }
+
+// src/provider.tsx
+var AllStakContext = React.createContext(null);
+var __providerOwnedInstance = null;
+var AllStakErrorBoundary = class extends React.Component {
+  constructor() {
+    super(...arguments);
+    this.state = { error: null };
+    this.resetError = () => 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 ?? ""
+      });
+      AllStak.captureException(error, {
+        componentStack: info.componentStack ?? "",
+        source: "AllStakProvider.ErrorBoundary"
+      });
+      if (this.props.debug) {
+        console.log(`[AllStak] Captured render error: ${error.message}`);
+      }
+    } catch {
+    }
+    try {
+      this.props.onError?.(error, info.componentStack ?? void 0);
+    } catch {
+    }
+  }
+  render() {
+    if (this.state.error) {
+      const { fallback } = this.props;
+      if (typeof fallback === "function") {
+        return fallback({ error: this.state.error, resetError: this.resetError });
+      }
+      if (fallback !== void 0) return fallback;
+      return null;
+    }
+    return this.props.children;
+  }
+};
+function AllStakProvider({
+  children,
+  apiKey,
+  environment,
+  release,
+  host,
+  user,
+  tags,
+  debug,
+  enableHttpTracking,
+  httpTracking,
+  captureConsole,
+  sampleRate,
+  beforeSend,
+  replay,
+  tracesSampleRate,
+  service,
+  dist,
+  destroyOnUnmount = false,
+  fallback,
+  onError,
+  autoErrorHandler,
+  autoPromiseRejections,
+  autoDeviceTags,
+  autoAppStateBreadcrumbs,
+  autoNetworkCapture,
+  autoFetchBreadcrumbs,
+  autoConsoleBreadcrumbs,
+  autoNavigationBreadcrumbs
+}) {
+  const clientRef = React.useRef(null);
+  if (!clientRef.current) {
+    const existing = AllStak._getInstance();
+    if (existing && __providerOwnedInstance === existing) {
+      clientRef.current = existing;
+      if (debug) {
+        console.log(`[AllStak] Reusing session ${AllStak.getSessionId()}`);
+      }
+    } else {
+      const config = {
+        apiKey,
+        environment,
+        release,
+        host,
+        user,
+        tags,
+        enableHttpTracking,
+        httpTracking,
+        captureConsole,
+        sampleRate,
+        beforeSend,
+        replay,
+        tracesSampleRate,
+        service,
+        dist
+      };
+      clientRef.current = AllStak.init(config);
+      __providerOwnedInstance = clientRef.current;
+      installReactNative({
+        autoErrorHandler,
+        autoPromiseRejections,
+        autoDeviceTags,
+        autoAppStateBreadcrumbs,
+        autoNetworkCapture,
+        autoFetchBreadcrumbs,
+        autoConsoleBreadcrumbs,
+        autoNavigationBreadcrumbs,
+        debugLogs: debug
+      });
+      if (debug) {
+        console.log(`[AllStak] Initialized \u2014 session ${AllStak.getSessionId()}`);
+      }
+    }
+  }
+  React.useEffect(() => {
+    return () => {
+      if (destroyOnUnmount) {
+        AllStak.destroy();
+        __providerOwnedInstance = null;
+        clientRef.current = null;
+        if (debug) console.log("[AllStak] Destroyed on unmount");
+      }
+    };
+  }, [destroyOnUnmount, debug]);
+  return /* @__PURE__ */ React.createElement(AllStakContext.Provider, { value: clientRef.current }, /* @__PURE__ */ React.createElement(AllStakErrorBoundary, { fallback, onError, debug }, 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 __resetProviderInstanceForTest() {
+  __providerOwnedInstance = null;
+}
+
+// src/index.ts
+var __testNativeModule = null;
+function __setNativeModuleForTest(mod) {
+  __testNativeModule = mod;
+}
+async function __devTriggerNativeCrash() {
+  try {
+    let native = __testNativeModule;
+    if (!native) {
+      const rn = require("react-native");
+      native = rn?.NativeModules?.AllStakNative;
+    }
+    if (!native || typeof native.__devTriggerCrash !== "function") return;
+    await native.__devTriggerCrash();
+  } catch {
+  }
+}
+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 {
+  }
+}
 export {
+  ALWAYS_REDACT_HEADERS,
+  ALWAYS_REDACT_QUERY,
   AllStak,
   AllStakClient,
+  AllStakProvider,
+  DEFAULT_REDACT_BODY_FIELDS,
   HttpRequestModule,
   INGEST_HOST,
+  REDACTED,
   ReplaySurrogate,
   SDK_NAME,
   SDK_VERSION,
   Scope,
+  __devTriggerNativeCrash,
+  __resetAutoNavigationFlagForTest,
+  __resetConsoleInstrumentationFlagForTest,
+  __resetProviderInstanceForTest,
   __setNativeModuleForTest,
   applyArchitectureTags,
+  captureBodyResult,
   detectArchitecture,
   drainPendingNativeCrashes,
   installReactNative,
   instrumentNavigationFromLinking,
-  instrumentReactNavigation
+  instrumentReactNavigation,
+  redactUrl,
+  sanitizeHeaders,
+  tryAutoInstrumentNavigation,
+  useAllStak
 };
 //# sourceMappingURL=index.mjs.map