@nathanclaire/edge-telemetry-sdk 3.0.0

package/README.md

@@ -0,0 +1,348 @@
+# @nathanclaire/edge-telemetry-sdk
+
+[![npm version](https://img.shields.io/npm/v/@nathanclaire/edge-telemetry-sdk.svg)](https://www.npmjs.com/package/@nathanclaire/edge-telemetry-sdk)
+[![React Native](https://img.shields.io/badge/React%20Native-0.64%2B-61DAFB.svg?style=flat&logo=react)](https://reactnative.dev/)
+[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-3178C6.svg?style=flat&logo=typescript)](https://www.typescriptlang.org/)
+
+A lightweight Real User Monitoring (RUM) SDK for **React Native** apps (and a web build via
+React Native Web). It captures performance, errors, network requests, device/network context,
+navigation and user interactions, then ships them as JSON to the shared **EdgeTelemetryProcessor**
+backend — the same backend the web, Android (Ionic) and iOS SDKs feed.
+
+One SDK, two builds. The bundler picks `index.native.js` or `index.web.js` from the
+`package.json` `exports` map — you always import from `@nathanclaire/edge-telemetry-sdk`.
+
+---
+
+## Contents
+
+- [Upgrading to v3](#upgrading-to-v3-breaking)
+- [Install](#install)
+- [Quick start](#quick-start)
+- [Configuration](#configuration)
+- [API](#api)
+- [What gets captured](#what-gets-captured)
+- [Wire format](#wire-format)
+- [Identity & IDs](#identity--ids)
+- [Reliability](#reliability)
+- [Debugging](#debugging)
+- [Development](#development)
+
+---
+
+## Upgrading to v3 (breaking)
+
+v3 is a **single clean break** onto the EdgeRum wire contract — no dual-emit, no v2 fallback.
+If you're coming from v2, the headlines:
+
+- `createTelemetry({ apiKey, endpoint, ... })` — **`apiKey` is now required** (must start with
+  `edge_`; sent as `X-API-Key`; init throws otherwise).
+- The POST body is the `telemetry_batch` envelope; timestamps are ISO-8601; device/network data
+  rides as a Context block on **every** event (the standalone `device_info`/`network_info`
+  events are gone).
+- Several event names changed and only the allowlist ships (`network_request` → `http.request`,
+  `screen_view` → `navigation`, …); other `log()` names arrive as `custom_event`.
+- New `debug` option (default `false`) silences all SDK console output.
+
+Full breaking-change list and migration checklist: **[CHANGELOG.md](./CHANGELOG.md)**.
+
+---
+
+## Install
+
+```bash
+npm install @nathanclaire/edge-telemetry-sdk
+```
+
+### React Native peer dependencies
+
+Native capture relies on these (install in your app):
+
+```bash
+npm install @react-native-async-storage/async-storage react-native-device-info @react-native-community/netinfo
+cd ios && pod install
+```
+
+| Peer dep | Used for |
+|---|---|
+| `@react-native-async-storage/async-storage` | persisted replay of failed batches |
+| `react-native-device-info` | `device.*` context (optional — degrades gracefully) |
+| `@react-native-community/netinfo` | `network.*` context + `network_change` |
+
+The **web build** uses browser APIs (`navigator`, `localStorage`) and needs none of the above.
+
+---
+
+## Quick start
+
+`createTelemetry()` returns a `TelemetryNative` or `TelemetryWeb` instance — the bundler chooses.
+**Every public method is `async`** (each awaits a lazily-built core), so `await` your calls.
+
+### React Native
+
+```typescript
+import { createTelemetry } from "@nathanclaire/edge-telemetry-sdk";
+
+const telemetry = createTelemetry({
+  apiKey: "edge_xxxxxxxx",                                  // required; must start with "edge_"
+  endpoint: "https://collector.example.com/collector/telemetry", // full POST URL, used verbatim
+  batchSize: 20,
+  flushIntervalMs: 10000,
+});
+
+await telemetry.log("checkout_started", { cart_value: 42 });
+```
+
+### React Web
+
+```typescript
+import { createTelemetry } from "@nathanclaire/edge-telemetry-sdk";
+
+const telemetry = createTelemetry({
+  apiKey: "edge_xxxxxxxx",
+  endpoint: "https://collector.example.com/collector/telemetry",
+  batchSize: 20,
+  flushIntervalMs: 10000,
+});
+
+await telemetry.log("checkout_started", { cart_value: 42 });
+```
+
+Once constructed, the SDK **auto-starts** its collectors — you don't wire them up: session start,
+crash/error capture, HTTP interception, frame + memory sampling, app foreground/background, and
+(web) navigation. You only opt in to navigation and interaction capture on native (below).
+
+---
+
+## Configuration
+
+```typescript
+type TelemetryOpts = {
+  apiKey: string;           // REQUIRED — must start with "edge_"; sent as X-API-Key
+  endpoint?: string;        // full collector POST URL (used verbatim). Default is a placeholder — always set it
+  batchSize?: number;       // events per flush. Core default 2 — set higher (e.g. 20) for production
+  flushIntervalMs?: number; // periodic flush. Default 10000; <= 0 disables the timer
+  captureConsole?: boolean; // funnel console.error/warn into app.crash. Default on (opt-out)
+  debug?: boolean;          // SDK-internal console diagnostics. Default false (silent)
+  sender?: Sender;          // override the transport (mainly for tests)
+};
+```
+
+- **`apiKey`** is validated at `createTelemetry()` — a key not starting with `edge_` throws
+  immediately, so misconfiguration fails fast instead of silently dropping data. `tenant_id`
+  is never sent; the backend resolves the tenant from the key.
+- **`endpoint`** is the exact URL the SDK POSTs to. Point it at your collector's telemetry path.
+
+---
+
+## API
+
+All methods return Promises. Available on both platforms unless marked **native-only**.
+
+### Core
+
+```typescript
+log(event: string, data?: Record<string, any>): Promise<void>   // custom event (see allowlist note)
+flush(): Promise<void>                                           // force-send the queue now
+shutdown(): Promise<void>                                        // clear the flush timer + final flush
+```
+
+> **Allowlist note:** only the allowlisted event names reach the backend as-is. Any other name
+> you pass to `log()` is shipped as `custom_event` with your original name in
+> `attributes["event.name"]` — so custom events are preserved, not dropped.
+
+### Identity
+
+```typescript
+identify(profile: {                     // EdgeRum-style — emits user.profile.update,
+  name?: string; email?: string;        // attaches identity to subsequent events, and
+  phone?: string; avatar?: string;      // PRESERVES the anonymous user.id
+  customAttributes?: Record<string, any>;
+}): Promise<void>
+
+setUserId(id: string): Promise<void>
+generateUserId(): Promise<string>
+setUserProfile(profile): Promise<void>
+setUserDetails(details): Promise<void>          // fullName/firstName/lastName/email/phone/avatar/customAttributes
+updateUserProfile(updates): Promise<void>
+getUserProfile(): Promise<UserProfile | undefined>
+clearUserProfile(): Promise<void>
+setUserName(fullName, firstName?, lastName?): Promise<void>
+setUserContact(email?, phone?): Promise<void>
+```
+
+```typescript
+await telemetry.identify({ name: "Ada Lovelace", email: "ada@example.com" });
+```
+
+### Context accessors
+
+```typescript
+getDeviceInfo(): Promise<DeviceInfo>
+getNetworkInfo(): Promise<NetworkInfo>
+```
+
+### Navigation & screens — **native-only**
+
+```typescript
+attachNavigation(navigationRef): Promise<void>   // React Navigation container ref → auto route tracking
+trackRoute(from: string, to: string): Promise<void>
+screenStart(name: string): Promise<void>         // → navigation
+screenEnd(name: string): Promise<void>           // → screen.duration (dwell ms)
+```
+
+```typescript
+import { NavigationContainer, useNavigationContainerRef } from "@react-navigation/native";
+
+const navRef = useNavigationContainerRef();
+// after the container mounts:
+await telemetry.attachNavigation(navRef);
+```
+
+On **web**, navigation is auto-tracked (History API) — no wiring needed.
+
+### User interactions (taps) — **native-only, best-effort**
+
+Native has no global tap stream, so the SDK gives you responder props to spread on your app root.
+Each tap emits `user.interaction` with `interaction.type` and the current screen when known. It
+observes the gesture without stealing it (no DOM `target_tag`/`target_class` — those are web-only).
+
+```tsx
+function Root() {
+  const [props, setProps] = React.useState({});
+  React.useEffect(() => { telemetry.interactionProps().then(setProps); }, []);
+  return <View style={{ flex: 1 }} {...props}><App /></View>;
+}
+```
+
+---
+
+## What gets captured
+
+Auto-started in the constructor (both platforms unless noted):
+
+| Signal | `eventName` / `metricName` | Type |
+|---|---|---|
+| Session start / end | `session.started`, `session.finalized` | event |
+| App foreground/background | `app_lifecycle` | event |
+| Route change / screen entry | `navigation` | event |
+| Screen dwell time | `screen.duration` | event |
+| HTTP request (fetch/XHR) | `http.request` | event |
+| Connectivity change | `network_change` | event |
+| JS error / crash / (opt-out) console errors | `app.crash` | event |
+| Identity update via `identify()` | `user.profile.update` | event |
+| Tap (native, best-effort) | `user.interaction` | event |
+| Custom `log()` name (non-allowlisted) | `custom_event` | event |
+| Memory sample | `memory_usage` | metric |
+| Frame render window | `frame_render_time` | metric |
+
+`app.crash` carries a `cause` discriminator and `crash.breadcrumbs` (last 20 actions,
+JSON-stringified). Sessions rotate after 30 minutes of inactivity; `session.finalized` flushes
+immediately and includes a journey summary + `sdk.error_count`.
+
+**Web-only signals** (`page_load`, `resource_timing`, `long_task`, and Web Vitals
+LCP/FCP/CLS/INP/TTFB) are emitted only by the web build — native never reports metrics it can't
+honestly measure.
+
+---
+
+## Wire format
+
+```
+POST <endpoint>
+Content-Type: application/json
+X-API-Key: edge_xxxxxxxx
+
+{
+  "type": "telemetry_batch",
+  "timestamp": "2026-07-02T06:00:00.000Z",   // ISO 8601
+  "batch_size": 3,
+  "events": [ /* TelemetryEvent, ... */ ]
+}
+```
+
+Each event/metric:
+
+```typescript
+type TelemetryEvent = {
+  type: "event" | "metric";
+  eventName?: string;                  // events
+  metricName?: string;                 // metrics
+  value?: number;                      // metrics
+  timestamp: string;                   // ISO 8601
+  attributes?: Record<string, any>;    // flat, dot-namespaced — includes the Context block
+};
+```
+
+Every record carries the flattened **Context block** in `attributes`: `app.*`, `device.*`,
+`network.*`, `session.*`, `user.id`, and `sdk.*` (`sdk.platform = "react-native"`,
+`sdk.version`). This makes each record self-describing and joinable without correlating against
+separate context events.
+
+---
+
+## Identity & IDs
+
+IDs use 16 hex chars of entropy; device/session are suffixed with the device OS, user is not:
+
+```
+device_{ms}_{16hex}_{ios|android}
+session_{ms}_{16hex}_{ios|android}
+user_{ms}_{16hex}
+```
+
+Conform to `^(session|device|user)_\d+_[0-9a-f]{16}(_(ios|android))?$`. The **web build** omits
+the OS suffix (`device.platform = "web"` still rides as an attribute).
+
+`identify()` attaches host-app identity (`user.name`/`email`/`phone`) to subsequent events and
+emits one `user.profile.update` — it never changes the SDK-owned anonymous `user.id`.
+
+---
+
+## Reliability
+
+- **Batching:** events queue and flush when `batchSize` is reached or every `flushIntervalMs`.
+- **Retry:** failed sends retry with exponential backoff + jitter.
+- **Persisted replay:** after final failure, batches are persisted (AsyncStorage on native,
+  `localStorage` on web, key `telemetry_failed_events`) and replayed on next init — telemetry
+  survives transient network loss.
+- **Web unload:** the web sender uses `fetch({ keepalive: true })` (not `sendBeacon`, which can't
+  set the required `X-API-Key` header) so in-flight batches survive page unload.
+
+---
+
+## Debugging
+
+The SDK is **silent by default**. To see its internal diagnostics while developing:
+
+```typescript
+createTelemetry({ apiKey: "edge_xxx", endpoint: "...", debug: true });
+```
+
+`debug: true` routes the SDK's `log`/`warn`/`error` to the console; with it off (the default),
+the SDK writes nothing to the host app's console.
+
+---
+
+## Development
+
+```bash
+npm run build      # vite build → dist/ (web + native entries, ESM + CJS)
+npm run dev        # vite in watch mode
+npm test           # vitest run
+npm run typecheck  # tsc --noEmit
+npm run clean      # remove dist/
+```
+
+`dist/` and `*.tgz` are git-ignored — `dist/` is regenerated by the build and published via the
+`package.json` `files` list. `prepare` runs the build, so installing this as a git dependency
+builds it automatically.
+
+Platform code is split by filename (`*.native.ts` / `*.web.ts`), not by runtime branching — the
+bundler selects the file. When adding a capability, keep the native and web adapters in lockstep.
+
+---
+
+## License
+
+ISC

package/dist/appLifecycle-Cynw0kAv.js

@@ -0,0 +1,14 @@
+class c {
+  constructor(t) {
+    this.telemetry = t;
+  }
+  onState(t) {
+    this.active !== void 0 && this.active !== t && this.telemetry.log("app_lifecycle", {
+      "app_lifecycle.state": t ? "foreground" : "background"
+    }), this.active = t;
+  }
+}
+export {
+  c as AppLifecycleEmitter
+};
+//# sourceMappingURL=appLifecycle-Cynw0kAv.js.map

package/dist/appLifecycle-Cynw0kAv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"appLifecycle-Cynw0kAv.js","sources":["../src/adapters/appLifecycle.ts"],"sourcesContent":["import { Telemetry } from \"../core/telemetry\";\n\n/**\n * Shared foreground/background emitter — the single source of truth so the native\n * (RN AppState) and web (visibilitychange) lifecycle adapters stay in lockstep on the\n * v3 `app_lifecycle` contract (#30).\n *\n * Feed it the current active state via `onState(isActive)`. It emits `app_lifecycle` only\n * on a transition, carrying the direction as `app_lifecycle.state` (foreground|background).\n */\nexport class AppLifecycleEmitter {\n  private active?: boolean;\n\n  constructor(private telemetry: Telemetry) {}\n\n  onState(isActive: boolean): void {\n    if (this.active !== undefined && this.active !== isActive) {\n      this.telemetry.log(\"app_lifecycle\", {\n        \"app_lifecycle.state\": isActive ? \"foreground\" : \"background\",\n      });\n    }\n    this.active = isActive;\n  }\n}\n"],"names":["AppLifecycleEmitter","telemetry","isActive"],"mappings":"AAUO,MAAMA,EAAoB;AAAA,EAG/B,YAAoBC,GAAsB;AAAtB,SAAA,YAAAA;AAAA,EAAuB;AAAA,EAE3C,QAAQC,GAAyB;AAC/B,IAAI,KAAK,WAAW,UAAa,KAAK,WAAWA,KAC/C,KAAK,UAAU,IAAI,iBAAiB;AAAA,MAClC,uBAAuBA,IAAW,eAAe;AAAA,IAAA,CAClD,GAEH,KAAK,SAASA;AAAA,EAChB;AACF;"}

package/dist/appLifecycle-DvJIt7ym.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});class t{constructor(e){this.telemetry=e}onState(e){this.active!==void 0&&this.active!==e&&this.telemetry.log("app_lifecycle",{"app_lifecycle.state":e?"foreground":"background"}),this.active=e}}exports.AppLifecycleEmitter=t;
+//# sourceMappingURL=appLifecycle-DvJIt7ym.cjs.map

package/dist/appLifecycle-DvJIt7ym.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"appLifecycle-DvJIt7ym.cjs","sources":["../src/adapters/appLifecycle.ts"],"sourcesContent":["import { Telemetry } from \"../core/telemetry\";\n\n/**\n * Shared foreground/background emitter — the single source of truth so the native\n * (RN AppState) and web (visibilitychange) lifecycle adapters stay in lockstep on the\n * v3 `app_lifecycle` contract (#30).\n *\n * Feed it the current active state via `onState(isActive)`. It emits `app_lifecycle` only\n * on a transition, carrying the direction as `app_lifecycle.state` (foreground|background).\n */\nexport class AppLifecycleEmitter {\n  private active?: boolean;\n\n  constructor(private telemetry: Telemetry) {}\n\n  onState(isActive: boolean): void {\n    if (this.active !== undefined && this.active !== isActive) {\n      this.telemetry.log(\"app_lifecycle\", {\n        \"app_lifecycle.state\": isActive ? \"foreground\" : \"background\",\n      });\n    }\n    this.active = isActive;\n  }\n}\n"],"names":["AppLifecycleEmitter","telemetry","isActive"],"mappings":"gFAUO,MAAMA,CAAoB,CAG/B,YAAoBC,EAAsB,CAAtB,KAAA,UAAAA,CAAuB,CAE3C,QAAQC,EAAyB,CAC3B,KAAK,SAAW,QAAa,KAAK,SAAWA,GAC/C,KAAK,UAAU,IAAI,gBAAiB,CAClC,sBAAuBA,EAAW,aAAe,YAAA,CAClD,EAEH,KAAK,OAASA,CAChB,CACF"}

package/dist/batch-CLBFgYPC.cjs

@@ -0,0 +1,2 @@
+"use strict";function e(t){return JSON.stringify({type:"telemetry_batch",timestamp:new Date().toISOString(),batch_size:t.length,events:t})}exports.buildBatch=e;
+//# sourceMappingURL=batch-CLBFgYPC.cjs.map

package/dist/batch-CLBFgYPC.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-CLBFgYPC.cjs","sources":["../src/adapters/batch.ts"],"sourcesContent":["import type { TelemetryEvent } from \"../core/telemetry\";\n\n// v3 wire envelope. Shared by both senders so the web and native POST bodies\n// stay byte-identical to the EdgeRum telemetry_batch contract.\nexport function buildBatch(events: TelemetryEvent[]): string {\n    return JSON.stringify({\n        type: \"telemetry_batch\",\n        timestamp: new Date().toISOString(),\n        batch_size: events.length,\n        events,\n    });\n}\n"],"names":["buildBatch","events"],"mappings":"aAIO,SAASA,EAAWC,EAAkC,CACzD,OAAO,KAAK,UAAU,CAClB,KAAM,kBACN,UAAW,IAAI,KAAA,EAAO,YAAA,EACtB,WAAYA,EAAO,OACnB,OAAAA,CAAA,CACH,CACL"}

package/dist/batch-DLG_gtOm.js

@@ -0,0 +1,12 @@
+function e(t) {
+  return JSON.stringify({
+    type: "telemetry_batch",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    batch_size: t.length,
+    events: t
+  });
+}
+export {
+  e as b
+};
+//# sourceMappingURL=batch-DLG_gtOm.js.map

package/dist/batch-DLG_gtOm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-DLG_gtOm.js","sources":["../src/adapters/batch.ts"],"sourcesContent":["import type { TelemetryEvent } from \"../core/telemetry\";\n\n// v3 wire envelope. Shared by both senders so the web and native POST bodies\n// stay byte-identical to the EdgeRum telemetry_batch contract.\nexport function buildBatch(events: TelemetryEvent[]): string {\n    return JSON.stringify({\n        type: \"telemetry_batch\",\n        timestamp: new Date().toISOString(),\n        batch_size: events.length,\n        events,\n    });\n}\n"],"names":["buildBatch","events"],"mappings":"AAIO,SAASA,EAAWC,GAAkC;AACzD,SAAO,KAAK,UAAU;AAAA,IAClB,MAAM;AAAA,IACN,YAAW,oBAAI,KAAA,GAAO,YAAA;AAAA,IACtB,YAAYA,EAAO;AAAA,IACnB,QAAAA;AAAA,EAAA,CACH;AACL;"}

package/dist/crashCapture-BYTM4FLC.cjs

@@ -0,0 +1,2 @@
+"use strict";function l(n,r={}){const s={"crash.cause":n,"crash.message":r.message??null,"crash.stacktrace":r.stacktrace??null};return r.fatal!==void 0&&(s["crash.fatal"]=r.fatal),s}function u(n,r=console){const s=r.error.bind(r),o=r.warn.bind(r);let a=!1;const c=(t,i)=>(...e)=>{if(!a){a=!0;try{n.log("app.crash",l(t,{message:e.map(String).join(" ")}))}finally{a=!1}}i(...e)};return r.error=c("ConsoleError",s),r.warn=c("ConsoleWarn",o),()=>{r.error=s,r.warn=o}}exports.buildCrashAttributes=l;exports.captureConsole=u;
+//# sourceMappingURL=crashCapture-BYTM4FLC.cjs.map

package/dist/crashCapture-BYTM4FLC.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"crashCapture-BYTM4FLC.cjs","sources":["../src/adapters/crashCapture.ts"],"sourcesContent":["import { Telemetry } from \"../core/telemetry\";\n\n// One `app.crash` stream, segmented by cause (lifts the iOS ADR-010 model). #28\nexport type CrashCause = \"Error\" | \"UnhandledRejection\" | \"ConsoleError\" | \"ConsoleWarn\";\n\nexport function buildCrashAttributes(\n  cause: CrashCause,\n  fields: { message?: unknown; stacktrace?: unknown; fatal?: boolean } = {},\n): Record<string, any> {\n  const attrs: Record<string, any> = {\n    \"crash.cause\": cause,\n    \"crash.message\": fields.message ?? null,\n    \"crash.stacktrace\": fields.stacktrace ?? null,\n  };\n  if (fields.fatal !== undefined) attrs[\"crash.fatal\"] = fields.fatal;\n  return attrs;\n}\n\n/**\n * Patch console.error/warn to funnel into `app.crash` (cause ConsoleError/ConsoleWarn).\n * Opt-out: callers only invoke this when console capture is enabled. Returns a restore fn.\n * A reentrancy guard prevents the SDK's own console writes during logging from re-capturing.\n */\nexport function captureConsole(\n  telemetry: Telemetry,\n  target: Pick<Console, \"error\" | \"warn\"> = console,\n): () => void {\n  const origError = target.error.bind(target);\n  const origWarn = target.warn.bind(target);\n  let inside = false;\n\n  const make = (cause: CrashCause, orig: (...a: any[]) => void) =>\n    (...args: any[]) => {\n      if (!inside) {\n        inside = true;\n        try {\n          telemetry.log(\"app.crash\", buildCrashAttributes(cause, { message: args.map(String).join(\" \") }));\n        } finally {\n          inside = false;\n        }\n      }\n      orig(...args);\n    };\n\n  target.error = make(\"ConsoleError\", origError);\n  target.warn = make(\"ConsoleWarn\", origWarn);\n\n  return () => { target.error = origError; target.warn = origWarn; };\n}\n"],"names":["buildCrashAttributes","cause","fields","attrs","captureConsole","telemetry","target","origError","origWarn","inside","make","orig","args"],"mappings":"aAKO,SAASA,EACdC,EACAC,EAAuE,GAClD,CACrB,MAAMC,EAA6B,CACjC,cAAeF,EACf,gBAAiBC,EAAO,SAAW,KACnC,mBAAoBA,EAAO,YAAc,IAAA,EAE3C,OAAIA,EAAO,QAAU,SAAWC,EAAM,aAAa,EAAID,EAAO,OACvDC,CACT,CAOO,SAASC,EACdC,EACAC,EAA0C,QAC9B,CACZ,MAAMC,EAAYD,EAAO,MAAM,KAAKA,CAAM,EACpCE,EAAWF,EAAO,KAAK,KAAKA,CAAM,EACxC,IAAIG,EAAS,GAEb,MAAMC,EAAO,CAACT,EAAmBU,IAC/B,IAAIC,IAAgB,CAClB,GAAI,CAACH,EAAQ,CACXA,EAAS,GACT,GAAI,CACFJ,EAAU,IAAI,YAAaL,EAAqBC,EAAO,CAAE,QAASW,EAAK,IAAI,MAAM,EAAE,KAAK,GAAG,CAAA,CAAG,CAAC,CACjG,QAAA,CACEH,EAAS,EACX,CACF,CACAE,EAAK,GAAGC,CAAI,CACd,EAEF,OAAAN,EAAO,MAAQI,EAAK,eAAgBH,CAAS,EAC7CD,EAAO,KAAOI,EAAK,cAAeF,CAAQ,EAEnC,IAAM,CAAEF,EAAO,MAAQC,EAAWD,EAAO,KAAOE,CAAU,CACnE"}

package/dist/crashCapture-D_rkkBVa.js

@@ -0,0 +1,31 @@
+function t(n, r = {}) {
+  const a = {
+    "crash.cause": n,
+    "crash.message": r.message ?? null,
+    "crash.stacktrace": r.stacktrace ?? null
+  };
+  return r.fatal !== void 0 && (a["crash.fatal"] = r.fatal), a;
+}
+function u(n, r = console) {
+  const a = r.error.bind(r), o = r.warn.bind(r);
+  let s = !1;
+  const c = (l, i) => (...e) => {
+    if (!s) {
+      s = !0;
+      try {
+        n.log("app.crash", t(l, { message: e.map(String).join(" ") }));
+      } finally {
+        s = !1;
+      }
+    }
+    i(...e);
+  };
+  return r.error = c("ConsoleError", a), r.warn = c("ConsoleWarn", o), () => {
+    r.error = a, r.warn = o;
+  };
+}
+export {
+  t as b,
+  u as c
+};
+//# sourceMappingURL=crashCapture-D_rkkBVa.js.map

package/dist/crashCapture-D_rkkBVa.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crashCapture-D_rkkBVa.js","sources":["../src/adapters/crashCapture.ts"],"sourcesContent":["import { Telemetry } from \"../core/telemetry\";\n\n// One `app.crash` stream, segmented by cause (lifts the iOS ADR-010 model). #28\nexport type CrashCause = \"Error\" | \"UnhandledRejection\" | \"ConsoleError\" | \"ConsoleWarn\";\n\nexport function buildCrashAttributes(\n  cause: CrashCause,\n  fields: { message?: unknown; stacktrace?: unknown; fatal?: boolean } = {},\n): Record<string, any> {\n  const attrs: Record<string, any> = {\n    \"crash.cause\": cause,\n    \"crash.message\": fields.message ?? null,\n    \"crash.stacktrace\": fields.stacktrace ?? null,\n  };\n  if (fields.fatal !== undefined) attrs[\"crash.fatal\"] = fields.fatal;\n  return attrs;\n}\n\n/**\n * Patch console.error/warn to funnel into `app.crash` (cause ConsoleError/ConsoleWarn).\n * Opt-out: callers only invoke this when console capture is enabled. Returns a restore fn.\n * A reentrancy guard prevents the SDK's own console writes during logging from re-capturing.\n */\nexport function captureConsole(\n  telemetry: Telemetry,\n  target: Pick<Console, \"error\" | \"warn\"> = console,\n): () => void {\n  const origError = target.error.bind(target);\n  const origWarn = target.warn.bind(target);\n  let inside = false;\n\n  const make = (cause: CrashCause, orig: (...a: any[]) => void) =>\n    (...args: any[]) => {\n      if (!inside) {\n        inside = true;\n        try {\n          telemetry.log(\"app.crash\", buildCrashAttributes(cause, { message: args.map(String).join(\" \") }));\n        } finally {\n          inside = false;\n        }\n      }\n      orig(...args);\n    };\n\n  target.error = make(\"ConsoleError\", origError);\n  target.warn = make(\"ConsoleWarn\", origWarn);\n\n  return () => { target.error = origError; target.warn = origWarn; };\n}\n"],"names":["buildCrashAttributes","cause","fields","attrs","captureConsole","telemetry","target","origError","origWarn","inside","make","orig","args"],"mappings":"AAKO,SAASA,EACdC,GACAC,IAAuE,IAClD;AACrB,QAAMC,IAA6B;AAAA,IACjC,eAAeF;AAAA,IACf,iBAAiBC,EAAO,WAAW;AAAA,IACnC,oBAAoBA,EAAO,cAAc;AAAA,EAAA;AAE3C,SAAIA,EAAO,UAAU,WAAWC,EAAM,aAAa,IAAID,EAAO,QACvDC;AACT;AAOO,SAASC,EACdC,GACAC,IAA0C,SAC9B;AACZ,QAAMC,IAAYD,EAAO,MAAM,KAAKA,CAAM,GACpCE,IAAWF,EAAO,KAAK,KAAKA,CAAM;AACxC,MAAIG,IAAS;AAEb,QAAMC,IAAO,CAACT,GAAmBU,MAC/B,IAAIC,MAAgB;AAClB,QAAI,CAACH,GAAQ;AACX,MAAAA,IAAS;AACT,UAAI;AACF,QAAAJ,EAAU,IAAI,aAAaL,EAAqBC,GAAO,EAAE,SAASW,EAAK,IAAI,MAAM,EAAE,KAAK,GAAG,EAAA,CAAG,CAAC;AAAA,MACjG,UAAA;AACE,QAAAH,IAAS;AAAA,MACX;AAAA,IACF;AACA,IAAAE,EAAK,GAAGC,CAAI;AAAA,EACd;AAEF,SAAAN,EAAO,QAAQI,EAAK,gBAAgBH,CAAS,GAC7CD,EAAO,OAAOI,EAAK,eAAeF,CAAQ,GAEnC,MAAM;AAAE,IAAAF,EAAO,QAAQC,GAAWD,EAAO,OAAOE;AAAA,EAAU;AACnE;"}

package/dist/crashHandler.web-BSxDpFTo.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const r=require("./crashCapture-BYTM4FLC.cjs");class c{constructor(t){this.telemetry=t}attach(t={}){const{captureConsole:a=!0}=t;return new Promise((o,n)=>{try{window.onerror=(e,i,h,u,s)=>{this.telemetry.log("app.crash",r.buildCrashAttributes("Error",{message:s?.message??e,stacktrace:s?.stack}))},window.onunhandledrejection=e=>{this.telemetry.log("app.crash",r.buildCrashAttributes("UnhandledRejection",{message:e.reason?.message??"Unhandled Promise Rejection",stacktrace:e.reason?.stack}))},a&&r.captureConsole(this.telemetry),o()}catch(e){n(e)}})}}exports.CrashHandler=c;
+//# sourceMappingURL=crashHandler.web-BSxDpFTo.cjs.map

package/dist/crashHandler.web-BSxDpFTo.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"crashHandler.web-BSxDpFTo.cjs","sources":["../src/adapters/web/crashHandler.web.ts"],"sourcesContent":["import { Telemetry } from \"../../core/telemetry\";\nimport { buildCrashAttributes, captureConsole } from \"../crashCapture\";\n\nexport type CrashHandlerOptions = { captureConsole?: boolean };\n\nexport class CrashHandler {\n    constructor(private telemetry: Telemetry) { }\n\n    // Lockstep with native: funnels JS errors, unhandled rejections and (opt-out)\n    // console.error/warn into one `app.crash` stream keyed by `crash.cause`. #28\n    attach(options: CrashHandlerOptions = {}): Promise<void> {\n        const { captureConsole: consoleEnabled = true } = options;\n        return new Promise((resolve, reject) => {\n            try {\n                window.onerror = (msg, _url, _line, _col, error) => {\n                    this.telemetry.log(\"app.crash\", buildCrashAttributes(\"Error\", {\n                        message: error?.message ?? msg,\n                        stacktrace: error?.stack,\n                    }));\n                };\n\n                window.onunhandledrejection = (event) => {\n                    this.telemetry.log(\"app.crash\", buildCrashAttributes(\"UnhandledRejection\", {\n                        message: event.reason?.message ?? \"Unhandled Promise Rejection\",\n                        stacktrace: event.reason?.stack,\n                    }));\n                };\n\n                if (consoleEnabled) captureConsole(this.telemetry);\n\n                resolve();\n            } catch (error) {\n                reject(error);\n            }\n        });\n    }\n}\n"],"names":["CrashHandler","telemetry","options","consoleEnabled","resolve","reject","msg","_url","_line","_col","error","buildCrashAttributes","event","captureConsole"],"mappings":"+HAKO,MAAMA,CAAa,CACtB,YAAoBC,EAAsB,CAAtB,KAAA,UAAAA,CAAwB,CAI5C,OAAOC,EAA+B,GAAmB,CACrD,KAAM,CAAE,eAAgBC,EAAiB,EAAA,EAASD,EAClD,OAAO,IAAI,QAAQ,CAACE,EAASC,IAAW,CACpC,GAAI,CACA,OAAO,QAAU,CAACC,EAAKC,EAAMC,EAAOC,EAAMC,IAAU,CAChD,KAAK,UAAU,IAAI,YAAaC,EAAAA,qBAAqB,QAAS,CAC1D,QAASD,GAAO,SAAWJ,EAC3B,WAAYI,GAAO,KAAA,CACtB,CAAC,CACN,EAEA,OAAO,qBAAwBE,GAAU,CACrC,KAAK,UAAU,IAAI,YAAaD,EAAAA,qBAAqB,qBAAsB,CACvE,QAASC,EAAM,QAAQ,SAAW,8BAClC,WAAYA,EAAM,QAAQ,KAAA,CAC7B,CAAC,CACN,EAEIT,GAAgBU,EAAAA,eAAe,KAAK,SAAS,EAEjDT,EAAA,CACJ,OAASM,EAAO,CACZL,EAAOK,CAAK,CAChB,CACJ,CAAC,CACL,CACJ"}

package/dist/crashHandler.web-D59bmhg9.js

@@ -0,0 +1,32 @@
+import { b as s, c } from "./crashCapture-D_rkkBVa.js";
+class u {
+  constructor(t) {
+    this.telemetry = t;
+  }
+  // Lockstep with native: funnels JS errors, unhandled rejections and (opt-out)
+  // console.error/warn into one `app.crash` stream keyed by `crash.cause`. #28
+  attach(t = {}) {
+    const { captureConsole: a = !0 } = t;
+    return new Promise((o, n) => {
+      try {
+        window.onerror = (e, i, h, m, r) => {
+          this.telemetry.log("app.crash", s("Error", {
+            message: r?.message ?? e,
+            stacktrace: r?.stack
+          }));
+        }, window.onunhandledrejection = (e) => {
+          this.telemetry.log("app.crash", s("UnhandledRejection", {
+            message: e.reason?.message ?? "Unhandled Promise Rejection",
+            stacktrace: e.reason?.stack
+          }));
+        }, a && c(this.telemetry), o();
+      } catch (e) {
+        n(e);
+      }
+    });
+  }
+}
+export {
+  u as CrashHandler
+};
+//# sourceMappingURL=crashHandler.web-D59bmhg9.js.map

package/dist/crashHandler.web-D59bmhg9.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crashHandler.web-D59bmhg9.js","sources":["../src/adapters/web/crashHandler.web.ts"],"sourcesContent":["import { Telemetry } from \"../../core/telemetry\";\nimport { buildCrashAttributes, captureConsole } from \"../crashCapture\";\n\nexport type CrashHandlerOptions = { captureConsole?: boolean };\n\nexport class CrashHandler {\n    constructor(private telemetry: Telemetry) { }\n\n    // Lockstep with native: funnels JS errors, unhandled rejections and (opt-out)\n    // console.error/warn into one `app.crash` stream keyed by `crash.cause`. #28\n    attach(options: CrashHandlerOptions = {}): Promise<void> {\n        const { captureConsole: consoleEnabled = true } = options;\n        return new Promise((resolve, reject) => {\n            try {\n                window.onerror = (msg, _url, _line, _col, error) => {\n                    this.telemetry.log(\"app.crash\", buildCrashAttributes(\"Error\", {\n                        message: error?.message ?? msg,\n                        stacktrace: error?.stack,\n                    }));\n                };\n\n                window.onunhandledrejection = (event) => {\n                    this.telemetry.log(\"app.crash\", buildCrashAttributes(\"UnhandledRejection\", {\n                        message: event.reason?.message ?? \"Unhandled Promise Rejection\",\n                        stacktrace: event.reason?.stack,\n                    }));\n                };\n\n                if (consoleEnabled) captureConsole(this.telemetry);\n\n                resolve();\n            } catch (error) {\n                reject(error);\n            }\n        });\n    }\n}\n"],"names":["CrashHandler","telemetry","options","consoleEnabled","resolve","reject","msg","_url","_line","_col","error","buildCrashAttributes","event","captureConsole"],"mappings":";AAKO,MAAMA,EAAa;AAAA,EACtB,YAAoBC,GAAsB;AAAtB,SAAA,YAAAA;AAAA,EAAwB;AAAA;AAAA;AAAA,EAI5C,OAAOC,IAA+B,IAAmB;AACrD,UAAM,EAAE,gBAAgBC,IAAiB,GAAA,IAASD;AAClD,WAAO,IAAI,QAAQ,CAACE,GAASC,MAAW;AACpC,UAAI;AACA,eAAO,UAAU,CAACC,GAAKC,GAAMC,GAAOC,GAAMC,MAAU;AAChD,eAAK,UAAU,IAAI,aAAaC,EAAqB,SAAS;AAAA,YAC1D,SAASD,GAAO,WAAWJ;AAAA,YAC3B,YAAYI,GAAO;AAAA,UAAA,CACtB,CAAC;AAAA,QACN,GAEA,OAAO,uBAAuB,CAACE,MAAU;AACrC,eAAK,UAAU,IAAI,aAAaD,EAAqB,sBAAsB;AAAA,YACvE,SAASC,EAAM,QAAQ,WAAW;AAAA,YAClC,YAAYA,EAAM,QAAQ;AAAA,UAAA,CAC7B,CAAC;AAAA,QACN,GAEIT,KAAgBU,EAAe,KAAK,SAAS,GAEjDT,EAAA;AAAA,MACJ,SAASM,GAAO;AACZ,QAAAL,EAAOK,CAAK;AAAA,MAChB;AAAA,IACJ,CAAC;AAAA,EACL;AACJ;"}

package/dist/crashHandlerNative.native-DeAFze4E.cjs

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const n=require("./crashCapture-BYTM4FLC.cjs");class c{constructor(s){this.telemetry=s}attach(s={}){const{captureConsole:l=!0}=s;return new Promise((o,i)=>{try{if(typeof ErrorUtils<"u"&&ErrorUtils.setGlobalHandler){const e=ErrorUtils.getGlobalHandler?.();ErrorUtils.setGlobalHandler((r,a)=>{this.telemetry.log("app.crash",n.buildCrashAttributes("Error",{message:r?.message,stacktrace:r?.stack,fatal:a})),e&&e(r,a)})}const t=e=>{this.telemetry.log("app.crash",n.buildCrashAttributes("UnhandledRejection",{message:e?.reason?.message??"Unhandled Promise Rejection",stacktrace:e?.reason?.stack}))};globalThis.addEventListener?globalThis.addEventListener("unhandledrejection",t):require("promise/setimmediate/rejection-tracking").enable({allRejections:!0,onUnhandled:(r,a)=>t({reason:a})}),l&&n.captureConsole(this.telemetry),o()}catch(t){i(t)}})}}exports.CrashHandlerNative=c;
+//# sourceMappingURL=crashHandlerNative.native-DeAFze4E.cjs.map

package/dist/crashHandlerNative.native-DeAFze4E.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"crashHandlerNative.native-DeAFze4E.cjs","sources":["../src/adapters/native/crashHandlerNative.native.ts"],"sourcesContent":["import { Telemetry } from \"../../core/telemetry\";\nimport { buildCrashAttributes, captureConsole } from \"../crashCapture\";\n\nexport type CrashHandlerOptions = { captureConsole?: boolean };\n\nexport class CrashHandlerNative {\n    constructor(private telemetry: Telemetry) { }\n\n    // Funnels JS errors, unhandled rejections and (opt-out) console.error/warn into one\n    // `app.crash` stream keyed by `crash.cause`. Console capture defaults on (opt-out). #28\n    attach(options: CrashHandlerOptions = {}): Promise<void> {\n        const { captureConsole: consoleEnabled = true } = options;\n        return new Promise((resolve, reject) => {\n            try {\n                if (typeof ErrorUtils !== \"undefined\" && ErrorUtils.setGlobalHandler) {\n                    const defaultHandler = ErrorUtils.getGlobalHandler?.();\n                    ErrorUtils.setGlobalHandler((error: any, isFatal?: boolean) => {\n                        this.telemetry.log(\"app.crash\", buildCrashAttributes(\"Error\", {\n                            message: error?.message,\n                            stacktrace: error?.stack,\n                            fatal: isFatal,\n                        }));\n                        if (defaultHandler) defaultHandler(error, isFatal);   // keep RN red screen in dev\n                    });\n                }\n\n                const onRejection = (event: any) => {\n                    this.telemetry.log(\"app.crash\", buildCrashAttributes(\"UnhandledRejection\", {\n                        message: event?.reason?.message ?? \"Unhandled Promise Rejection\",\n                        stacktrace: event?.reason?.stack,\n                    }));\n                };\n\n                if (globalThis.addEventListener) {\n                    globalThis.addEventListener(\"unhandledrejection\", onRejection);\n                } else {\n                    const tracking = require(\"promise/setimmediate/rejection-tracking\");\n                    tracking.enable({\n                        allRejections: true,\n                        onUnhandled: (_id: any, error: any) =>\n                            onRejection({ reason: error }),\n                    });\n                }\n\n                if (consoleEnabled) captureConsole(this.telemetry);\n\n                resolve();\n            } catch (error) {\n                reject(error);\n            }\n        });\n    }\n}\n"],"names":["CrashHandlerNative","telemetry","options","consoleEnabled","resolve","reject","defaultHandler","error","isFatal","buildCrashAttributes","onRejection","event","_id","captureConsole"],"mappings":"+HAKO,MAAMA,CAAmB,CAC5B,YAAoBC,EAAsB,CAAtB,KAAA,UAAAA,CAAwB,CAI5C,OAAOC,EAA+B,GAAmB,CACrD,KAAM,CAAE,eAAgBC,EAAiB,EAAA,EAASD,EAClD,OAAO,IAAI,QAAQ,CAACE,EAASC,IAAW,CACpC,GAAI,CACA,GAAI,OAAO,WAAe,KAAe,WAAW,iBAAkB,CAClE,MAAMC,EAAiB,WAAW,mBAAA,EAClC,WAAW,iBAAiB,CAACC,EAAYC,IAAsB,CAC3D,KAAK,UAAU,IAAI,YAAaC,EAAAA,qBAAqB,QAAS,CAC1D,QAASF,GAAO,QAChB,WAAYA,GAAO,MACnB,MAAOC,CAAA,CACV,CAAC,EACEF,GAAgBA,EAAeC,EAAOC,CAAO,CACrD,CAAC,CACL,CAEA,MAAME,EAAeC,GAAe,CAChC,KAAK,UAAU,IAAI,YAAaF,EAAAA,qBAAqB,qBAAsB,CACvE,QAASE,GAAO,QAAQ,SAAW,8BACnC,WAAYA,GAAO,QAAQ,KAAA,CAC9B,CAAC,CACN,EAEI,WAAW,iBACX,WAAW,iBAAiB,qBAAsBD,CAAW,EAE5C,QAAQ,yCAAyC,EACzD,OAAO,CACZ,cAAe,GACf,YAAa,CAACE,EAAUL,IACpBG,EAAY,CAAE,OAAQH,EAAO,CAAA,CACpC,EAGDJ,GAAgBU,EAAAA,eAAe,KAAK,SAAS,EAEjDT,EAAA,CACJ,OAASG,EAAO,CACZF,EAAOE,CAAK,CAChB,CACJ,CAAC,CACL,CACJ"}

package/dist/crashHandlerNative.native-d7qJkzA6.js

@@ -0,0 +1,41 @@
+import { b as n, c } from "./crashCapture-D_rkkBVa.js";
+class m {
+  constructor(s) {
+    this.telemetry = s;
+  }
+  // Funnels JS errors, unhandled rejections and (opt-out) console.error/warn into one
+  // `app.crash` stream keyed by `crash.cause`. Console capture defaults on (opt-out). #28
+  attach(s = {}) {
+    const { captureConsole: l = !0 } = s;
+    return new Promise((o, i) => {
+      try {
+        if (typeof ErrorUtils < "u" && ErrorUtils.setGlobalHandler) {
+          const e = ErrorUtils.getGlobalHandler?.();
+          ErrorUtils.setGlobalHandler((r, a) => {
+            this.telemetry.log("app.crash", n("Error", {
+              message: r?.message,
+              stacktrace: r?.stack,
+              fatal: a
+            })), e && e(r, a);
+          });
+        }
+        const t = (e) => {
+          this.telemetry.log("app.crash", n("UnhandledRejection", {
+            message: e?.reason?.message ?? "Unhandled Promise Rejection",
+            stacktrace: e?.reason?.stack
+          }));
+        };
+        globalThis.addEventListener ? globalThis.addEventListener("unhandledrejection", t) : require("promise/setimmediate/rejection-tracking").enable({
+          allRejections: !0,
+          onUnhandled: (r, a) => t({ reason: a })
+        }), l && c(this.telemetry), o();
+      } catch (t) {
+        i(t);
+      }
+    });
+  }
+}
+export {
+  m as CrashHandlerNative
+};
+//# sourceMappingURL=crashHandlerNative.native-d7qJkzA6.js.map

package/dist/crashHandlerNative.native-d7qJkzA6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"crashHandlerNative.native-d7qJkzA6.js","sources":["../src/adapters/native/crashHandlerNative.native.ts"],"sourcesContent":["import { Telemetry } from \"../../core/telemetry\";\nimport { buildCrashAttributes, captureConsole } from \"../crashCapture\";\n\nexport type CrashHandlerOptions = { captureConsole?: boolean };\n\nexport class CrashHandlerNative {\n    constructor(private telemetry: Telemetry) { }\n\n    // Funnels JS errors, unhandled rejections and (opt-out) console.error/warn into one\n    // `app.crash` stream keyed by `crash.cause`. Console capture defaults on (opt-out). #28\n    attach(options: CrashHandlerOptions = {}): Promise<void> {\n        const { captureConsole: consoleEnabled = true } = options;\n        return new Promise((resolve, reject) => {\n            try {\n                if (typeof ErrorUtils !== \"undefined\" && ErrorUtils.setGlobalHandler) {\n                    const defaultHandler = ErrorUtils.getGlobalHandler?.();\n                    ErrorUtils.setGlobalHandler((error: any, isFatal?: boolean) => {\n                        this.telemetry.log(\"app.crash\", buildCrashAttributes(\"Error\", {\n                            message: error?.message,\n                            stacktrace: error?.stack,\n                            fatal: isFatal,\n                        }));\n                        if (defaultHandler) defaultHandler(error, isFatal);   // keep RN red screen in dev\n                    });\n                }\n\n                const onRejection = (event: any) => {\n                    this.telemetry.log(\"app.crash\", buildCrashAttributes(\"UnhandledRejection\", {\n                        message: event?.reason?.message ?? \"Unhandled Promise Rejection\",\n                        stacktrace: event?.reason?.stack,\n                    }));\n                };\n\n                if (globalThis.addEventListener) {\n                    globalThis.addEventListener(\"unhandledrejection\", onRejection);\n                } else {\n                    const tracking = require(\"promise/setimmediate/rejection-tracking\");\n                    tracking.enable({\n                        allRejections: true,\n                        onUnhandled: (_id: any, error: any) =>\n                            onRejection({ reason: error }),\n                    });\n                }\n\n                if (consoleEnabled) captureConsole(this.telemetry);\n\n                resolve();\n            } catch (error) {\n                reject(error);\n            }\n        });\n    }\n}\n"],"names":["CrashHandlerNative","telemetry","options","consoleEnabled","resolve","reject","defaultHandler","error","isFatal","buildCrashAttributes","onRejection","event","_id","captureConsole"],"mappings":";AAKO,MAAMA,EAAmB;AAAA,EAC5B,YAAoBC,GAAsB;AAAtB,SAAA,YAAAA;AAAA,EAAwB;AAAA;AAAA;AAAA,EAI5C,OAAOC,IAA+B,IAAmB;AACrD,UAAM,EAAE,gBAAgBC,IAAiB,GAAA,IAASD;AAClD,WAAO,IAAI,QAAQ,CAACE,GAASC,MAAW;AACpC,UAAI;AACA,YAAI,OAAO,aAAe,OAAe,WAAW,kBAAkB;AAClE,gBAAMC,IAAiB,WAAW,mBAAA;AAClC,qBAAW,iBAAiB,CAACC,GAAYC,MAAsB;AAC3D,iBAAK,UAAU,IAAI,aAAaC,EAAqB,SAAS;AAAA,cAC1D,SAASF,GAAO;AAAA,cAChB,YAAYA,GAAO;AAAA,cACnB,OAAOC;AAAA,YAAA,CACV,CAAC,GACEF,KAAgBA,EAAeC,GAAOC,CAAO;AAAA,UACrD,CAAC;AAAA,QACL;AAEA,cAAME,IAAc,CAACC,MAAe;AAChC,eAAK,UAAU,IAAI,aAAaF,EAAqB,sBAAsB;AAAA,YACvE,SAASE,GAAO,QAAQ,WAAW;AAAA,YACnC,YAAYA,GAAO,QAAQ;AAAA,UAAA,CAC9B,CAAC;AAAA,QACN;AAEA,QAAI,WAAW,mBACX,WAAW,iBAAiB,sBAAsBD,CAAW,IAE5C,QAAQ,yCAAyC,EACzD,OAAO;AAAA,UACZ,eAAe;AAAA,UACf,aAAa,CAACE,GAAUL,MACpBG,EAAY,EAAE,QAAQH,GAAO;AAAA,QAAA,CACpC,GAGDJ,KAAgBU,EAAe,KAAK,SAAS,GAEjDT,EAAA;AAAA,MACJ,SAASG,GAAO;AACZ,QAAAF,EAAOE,CAAK;AAAA,MAChB;AAAA,IACJ,CAAC;AAAA,EACL;AACJ;"}

package/dist/debug-DsvQ9y3W.js

@@ -0,0 +1,68 @@
+class r {
+  async log(s, t) {
+    return (await this.instancePromise).log(s, t);
+  }
+  async flush() {
+    return (await this.instancePromise).flush();
+  }
+  async shutdown() {
+    return (await this.instancePromise).shutdown();
+  }
+  async trackErrors(s) {
+    const { CrashHandlerNative: t } = await import("./crashHandlerNative.native-d7qJkzA6.js"), e = await this.instancePromise, a = new t(e);
+    return e.trackErrors(a, s);
+  }
+  // ---------- User Profile Management ----------
+  async setUserId(s) {
+    (await this.instancePromise).setUserId(s);
+  }
+  async generateUserId() {
+    return (await this.instancePromise).generateUserId();
+  }
+  async setUserProfile(s) {
+    (await this.instancePromise).setUserProfile(s);
+  }
+  async setUserDetails(s) {
+    (await this.instancePromise).setUserDetails(s);
+  }
+  async updateUserProfile(s) {
+    (await this.instancePromise).updateUserProfile(s);
+  }
+  async getUserProfile() {
+    return (await this.instancePromise).getUserProfile();
+  }
+  async clearUserProfile() {
+    (await this.instancePromise).clearUserProfile();
+  }
+  async setUserName(s, t, e) {
+    (await this.instancePromise).setUserName(s, t, e);
+  }
+  async setUserContact(s, t) {
+    (await this.instancePromise).setUserContact(s, t);
+  }
+  // EdgeRum-style identify(): emits user.profile.update, preserves the anonymous user.id (#31)
+  async identify(s) {
+    return (await this.instancePromise).identify(s);
+  }
+}
+let i = !1;
+function o(n) {
+  i = n;
+}
+const c = {
+  log: (...n) => {
+    i && console.log(...n);
+  },
+  warn: (...n) => {
+    i && console.warn(...n);
+  },
+  error: (...n) => {
+    i && console.error(...n);
+  }
+};
+export {
+  r as T,
+  c as d,
+  o as s
+};
+//# sourceMappingURL=debug-DsvQ9y3W.js.map