@nathanclaire/edge-telemetry-sdk 3.0.0 → 4.0.0

package/dist/telemetry-ByDJIz_9.js

@@ -0,0 +1,1280 @@
+import { n as O, p as S, f as M, b as U, d as o, i as x, m as V } from "./memoryStore-F5I-GQKM.js";
+import { N as F } from "./navigationTracker-BmywA_Bg.js";
+import { N as I } from "./loadingTime-ZkYvFijA.js";
+import { b as z } from "./crashCapture-BW8WuyaU.js";
+class L {
+  constructor(e) {
+    this.startTimes = /* @__PURE__ */ new Map(), this.telemetry = e;
+  }
+  // Screen entry → v3 `navigation` (replaces v2 screen_view). Baseline shape follows the
+  // reference/Angular keys; iOS reconciliation is OPEN (see additions ledger).
+  async startScreen(e) {
+    const t = this.lastScreen;
+    this.markStart(e), this.lastScreen = e, await this.telemetry.log("navigation", {
+      "navigation.from_screen": t ?? null,
+      "navigation.to_screen": e,
+      "navigation.method": "screen_start",
+      "navigation.route_type": "screen"
+    }), await this.telemetry.enterView(e, "explicit");
+  }
+  /**
+   * Arm the dwell clock without emitting `navigation`. The route-change path (§4.11) has
+   * already emitted its own `navigation` with `method: "push"`, and emitting a second one
+   * with `method: "screen_start"` for the same transition would double the table.
+   */
+  markStart(e) {
+    this.startTimes.set(e, Date.now()), this.telemetry.currentScreen = e, this.lastScreen = e;
+  }
+  // Screen exit → v3 `screen.duration` with dwell ms (replaces screen_end + performance.screen_duration).
+  async endScreen(e) {
+    const t = this.startTimes.get(e);
+    if (!t) return;
+    const s = Date.now() - t;
+    this.startTimes.delete(e), await this.telemetry.log("screen.duration", {
+      "screen.name": e,
+      "screen.duration_ms": s,
+      "screen.exit_method": "navigation"
+    });
+  }
+}
+function u(i = 16) {
+  if (typeof globalThis.crypto?.getRandomValues != "function")
+    throw new Error(
+      "edge-telemetry: crypto.getRandomValues is unavailable, so no id can be minted. On React Native this means react-native-get-random-values failed to load — reinstall it and rebuild."
+    );
+  const e = new Uint8Array(Math.ceil(i / 2));
+  crypto.getRandomValues(e);
+  let t = "";
+  for (const s of e) t += s.toString(16).padStart(2, "0");
+  return t.slice(0, i);
+}
+const g = { none: 0, url: 1, route: 2, explicit: 3 }, _ = "unknown", H = 16;
+function b() {
+  return `view_${Date.now()}_${u(16)}`;
+}
+class $ {
+  constructor(e) {
+    this.telemetry = e, this.activityListeners = /* @__PURE__ */ new Set(), this.boundaryListeners = /* @__PURE__ */ new Set(), this.retiredNames = /* @__PURE__ */ new Map(), this.host = typeof location < "u" && location?.origin ? location.origin : void 0;
+    const t = Date.now();
+    this.view = {
+      id: b(),
+      name: _,
+      source: "none",
+      referrer: "",
+      loadType: "initial_load",
+      elapsed: 0,
+      resumedAt: t,
+      errors: 0,
+      actions: 0,
+      // The launch view is the one `load_type` that seeds from the platform's
+      // runtime-ready marker: it is busy until the bundle has evaluated (§4.5.2).
+      settle: new I(t, { awaitRuntimeReady: !0 }),
+      // The launch root is live here — it is minted in the same `Telemetry` constructor,
+      // just above this one — so the initial view is its child and a web hard load
+      // reports `launch`, never `navigation` (§6.2).
+      span: e.trace?.viewSpan(t) ?? {}
+    };
+  }
+  /** The two keys the Context block carries on every row. Name resolves at log time. */
+  get id() {
+    return this.view.id;
+  }
+  get name() {
+    return this.view.name;
+  }
+  /**
+   * §3.1 — `view.name` for a **frozen** `view.id`. A span-carrying row pins itself to the
+   * view live at span start, and its name is still resolved at log time, so an
+   * `http.request` that outlives a route change reports the departing view's *current*
+   * best name rather than a stale copy taken at send.
+   *
+   * ponytail: a bounded ring of retired names, not a full history. A span outliving
+   * `MAX_RETIRED_VIEW_NAMES` boundaries is a request the settle cap (30 s) already gave up
+   * on; it degrades to `"unknown"`, which is what a never-named view reports anyway.
+   */
+  nameOf(e) {
+    return e === this.view.id ? this.view.name : this.retiredNames.get(e) ?? _;
+  }
+  /**
+   * The name ladder (§4.5.1), and the only path that mints a view from a *name*.
+   *
+   * - a **higher** rung re-stamps the name and never changes `view.id` — that is what
+   *   "rank beats order" means, and it is why a route name arriving after a URL-derived
+   *   one upgrades the view in place instead of splitting it in two;
+   * - a **lower** rung is ignored outright, whenever it arrives — ⚠ *including its
+   *   boundary*. A host that mixes rung 1 with `attachNavigation` therefore pins the view
+   *   to the `screenStart` name until the next `screenStart`: route changes stop minting
+   *   successors, and dwell keeps accruing under the explicit name. That is what §4.5.1's
+   *   "a lower rung arriving later does not overwrite a higher one" costs, and the two
+   *   rungs describing one navigation (the upgrade window) is the case it exists for.
+   *   It needs a contract ruling, not a local invention — see CLAUDE.md's known gaps;
+   * - the **same** rung naming a different screen is a genuine navigation, so it ends the
+   *   view and mints a successor.
+   *
+   * Rungs 1 and 2 are handed through unnormalized: a host naming a screen "Step 2 of 3"
+   * must not receive "Step {id} of {id}". The caller normalizes rung 3, not this method.
+   */
+  async navigate(e, t) {
+    const s = g[t], r = g[this.view.source];
+    if (!(s < r)) {
+      if (s > r) {
+        this.view.name = e, this.view.source = t;
+        return;
+      }
+      e !== this.view.name && await this.exit("route_change", e, t);
+    }
+  }
+  /** `view.error_count` — `app.crash` rows sharing this `view.id`. A closed enumeration. */
+  countError() {
+    this.view.errors++;
+  }
+  /** `view.action_count` — interaction rows sharing this `view.id`. */
+  countAction() {
+    this.view.actions++;
+  }
+  /**
+   * An HTTP request started (§4.5.2). Returns its completion callback, **bound to the view
+   * that was live at start** — a request that finishes after a route change belongs to the
+   * view it started in and does not hold the arriving one open. The collector's own POST
+   * never reaches here; the interceptors filter it before calling.
+   */
+  requestStarted(e) {
+    return this.notifyActivity(), this.view.settle.requestStarted(e);
+  }
+  /**
+   * §4.6's dead-click gate, in the two places this manager already sees: a request started
+   * and a view minted (a route change, a resume, a session rotation). The web tracker adds
+   * DOM mutation on top, which it can observe on its own; these two it cannot.
+   *
+   * Deliberately fires for the background and rotation boundaries too. Those are not
+   * navigations the click caused, so counting them as aliveness **under-reports** dead
+   * clicks — which is the direction §4.6 requires: `ui.dead` must never falsely accuse.
+   *
+   * @returns an unsubscribe, so a tracker that is torn down does not keep the manager alive.
+   */
+  onActivity(e) {
+    return this.activityListeners.add(e), () => {
+      this.activityListeners.delete(e);
+    };
+  }
+  notifyActivity() {
+    for (const e of this.activityListeners) e();
+  }
+  /**
+   * §5.1's view-boundary reset. A subscriber is **awaited inside `beginView`, before the
+   * successor replaces the current view**, so anything it emits is stamped with the
+   * departing `view.id`. That ordering is the whole feature: a fixed 10 s frame window
+   * straddling a route change otherwise charges the departing screen's dropped frames to
+   * the arriving one — backwards for the one query the metric exists to serve.
+   *
+   * ⚠ **It does not fire on the `session_rotation` boundary**, and that is deliberate.
+   * `newSession()` installs the new `session.id` *before* minting the successor view, so a
+   * row emitted there would carry the new `session.id` with the departing `view.id` — the
+   * one thing §4.5's "`view.id` never spans a `session.id`" forbids. Emitting *before* the
+   * rotation instead is worse: `logMetric` re-checks session expiry, `lastActivity` is
+   * still stale at that point, and the emit would rotate the session a second time. The
+   * accepted residue is a frame window that carries across a rotation — at most one
+   * unflushed window, of a session that ended by idleness.
+   *
+   * The successor's load type is handed to the subscriber so it can tell the two firing
+   * boundaries apart: `frame_render_time` wants both, while §5.3's running CLS/INP values
+   * want **`"resume"` — the background boundary — only**. Emitting a page-load-scoped vital
+   * at a soft navigation would ship a second row for the same page load and stamp it with
+   * a `view.id` that is not the initial view's.
+   *
+   * @returns an unsubscribe, so a torn-down subscriber does not keep the manager alive.
+   */
+  onBoundary(e) {
+    return this.boundaryListeners.add(e), () => {
+      this.boundaryListeners.delete(e);
+    };
+  }
+  /**
+   * The platform's runtime-ready marker — `loadEventEnd` on web,
+   * `performance.rnStartupTiming` on native — or `undefined` where the platform has none.
+   *
+   * Forwarded to whatever view is current, which is safe because a view that was never gated
+   * *ignores* the seed — enforced in `NetworkSettle`, not assumed here. On web the `load`
+   * event routinely arrives after the first route change, and flooring that view's settle at
+   * the page's load time would charge the launch's cost to a route change.
+   */
+  seedRuntimeReady(e) {
+    this.view.settle.seedRuntimeReady(e);
+  }
+  /**
+   * Emit the `view` event for the current view. Its `view.name` is authoritative and its
+   * `view.name_source` reports the *final* rung; the Context-block copy on rows emitted
+   * early in the view may still carry a lower rung's name (§4.5.1).
+   *
+   * `view.loading_time` is **omitted when null**, following this contract's general
+   * absent-means-the-SDK-had-nothing discipline (§4.11 names `navigation.from_screen` as the
+   * only explicit wire null). `view.loading_time_outcome` always ships: it is what tells the
+   * three null causes apart, and reading p75-of-settled beside %-capped is the whole point.
+   */
+  async endView() {
+    const e = this.view, { loadingTime: t, outcome: s } = e.settle.resolve();
+    await this.telemetry.log("view", {
+      // A **point span** (§6.3): `span.start_time` from view entry and never
+      // `span.duration_ms`. View dwell is `view.time_spent`, not span width — a width
+      // here would stretch every tap-that-navigates envelope across the whole visit.
+      ...e.span,
+      ...this.host ? { "view.host": this.host } : {},
+      "view.referrer": e.referrer,
+      "view.load_type": e.loadType,
+      "view.name_source": e.source,
+      "view.time_spent": this.timeSpent(),
+      ...t === null ? {} : { "view.loading_time": t },
+      "view.loading_time_outcome": s,
+      "view.error_count": e.errors,
+      "view.action_count": e.actions,
+      "view.request_count": e.settle.requestCount
+    });
+  }
+  /**
+   * Mint the successor. Called directly by session rotation, which has to mint *after*
+   * the new `session.id` is in place — `view.id` never spans a `session.id` (§4.5).
+   * An unnamed successor carries the departing view's name: backgrounding and a session
+   * rotation do not move the user off the screen they were on.
+   */
+  async beginView(e, t, s) {
+    if (this.notifyActivity(), e !== "session_rotation")
+      for (const n of this.boundaryListeners)
+        try {
+          await n(e);
+        } catch {
+        }
+    const r = this.view, a = Date.now();
+    if (this.retiredNames.set(r.id, r.name), this.retiredNames.size > H) {
+      const n = this.retiredNames.keys().next();
+      n.done || this.retiredNames.delete(n.value);
+    }
+    this.view = {
+      id: b(),
+      name: t ?? r.name,
+      source: s ?? r.source,
+      referrer: r.name,
+      loadType: e,
+      elapsed: 0,
+      resumedAt: a,
+      errors: 0,
+      actions: 0,
+      // No runtime-ready seed: only `initial_load` has a platform marker to wait on.
+      settle: new I(a),
+      // A view start *extends* the live root; with none live it mints a `navigation`
+      // one (§6.2). Its exit does not extend anything (§6.7).
+      span: this.telemetry.trace?.viewSpan(a) ?? {}
+    };
+  }
+  /** A boundary that stays inside one session: emit, then mint the successor. */
+  async exit(e, t, s) {
+    await this.endView(), await this.beginView(e, t, s);
+  }
+  /**
+   * The background boundary. The successor is minted immediately — `view.id` must never
+   * be absent — but its clock starts paused, so a night spent backgrounded does not land
+   * as dwell on whatever screen the user left open.
+   */
+  async background() {
+    await this.exit("resume");
+    const e = this.view;
+    e.elapsed += this.sinceResume(), e.resumedAt = void 0;
+  }
+  /** The matching foreground edge: re-arm the paused clock. */
+  foreground() {
+    this.view.resumedAt ??= Date.now();
+  }
+  sinceResume() {
+    return this.view.resumedAt === void 0 ? 0 : Date.now() - this.view.resumedAt;
+  }
+  timeSpent() {
+    return Math.max(0, this.view.elapsed + this.sinceResume());
+  }
+}
+const j = 2e3, B = 1e4, W = () => u(32), N = () => u(16);
+class K {
+  /**
+   * @param launchStartMs what `app.start` reports as `span.start_time` — and **neither
+   * value is a fork time** (§6.2). Web passes `performance.timeOrigin` (true navigation
+   * start); native leaves it defaulted to `initialize()`, because everything before the
+   * JS bundle loads is invisible and JS cannot see process fork. Do not compare the two
+   * platforms' launch envelopes as if they measured the same interval.
+   */
+  constructor(e, t) {
+    this.allowlist = O(t);
+    const s = Date.now();
+    this.launch = this.mint("launch", s, e ?? s);
+  }
+  /**
+   * §4.1's `sdk.trace_allowlist_size` — **count only, never the hosts**, so an operator can
+   * tell "nobody opted in" apart from "the header is being stripped" without the SDK
+   * shipping a customer's internal hostnames to the collector.
+   */
+  allowlistSize() {
+    return this.allowlist.size;
+  }
+  /**
+   * `app.start`'s own row — a root, so `span.id === rum.action.id` and there is no
+   * `parent.span.id`. No `span.duration_ms` either: roots derive theirs server-side.
+   */
+  launchRootAttributes() {
+    return l(this.launch, !0, this.launch.spanStartMs).keys;
+  }
+  /**
+   * Tier 1 for a `view`, captured at view **entry** — the action that opened the screen,
+   * not the one that closed it (§6.3). A **point span**: `span.start_time` and never
+   * `span.duration_ms`, because view dwell is not span duration and a width here would
+   * stretch every tap-that-navigates envelope across the whole time the user sat there.
+   */
+  viewSpan(e) {
+    const { root: t, isRoot: s } = this.attach("navigation", e);
+    return l(t, s, e).keys;
+  }
+  /**
+   * Tier 1 for a `ui.interaction`, captured at the click's **mint** (§4.6/§6.2). The one
+   * unconditional mint in the table: a tap is a new user action by definition, so it
+   * *replaces* whatever root was live rather than joining it — which is what makes the
+   * request a tap fires a child of the tap and not of the route change before it.
+   *
+   * A root, so `span.id === rum.action.id`, no `parent.span.id`, and no `span.duration_ms`
+   * (§6.1 — a root's width is derived server-side).
+   */
+  interactionSpan(e) {
+    const t = this.mint("interaction", e, e);
+    return l(t, !0, e).keys;
+  }
+  /**
+   * Tier 1 for an `http.request`, captured at **send** — the root live then is the parent,
+   * and `span.start_time` is the send — plus §6.5's outcome ladder and the one header the
+   * SDK ever writes. Returns the finisher, so duration is stamped from the same pair of
+   * timestamps the row's `http.duration_ms` uses.
+   *
+   * ponytail: a `send()` that throws synchronously never calls the finisher, so a root it
+   * minted lives on for up to 2 s with no row describing it. Rare enough to leave; give
+   * the finisher a `discard()` sibling if the orphan ratio ever shows up.
+   */
+  requestTrace(e, t) {
+    const s = this.decide(t);
+    if (s === "adopted") {
+      const d = S(t.consumerTraceparent), C = {
+        "trace.id": d.traceId,
+        "span.id": d.spanId,
+        "rum.action.id": d.spanId,
+        "span.start_time": new Date(e).toISOString(),
+        "traceparent.outcome": "adopted"
+      };
+      return { finish: () => C };
+    }
+    const { root: r, isRoot: a, attribution: n } = this.attach("request", e), h = s === "inject" ? n : s, c = l(r, a, e), w = {
+      ...c.keys,
+      ...h ? { "traceparent.outcome": h } : {}
+    }, y = a ? () => w : (d) => ({ ...w, "span.duration_ms": Math.max(0, d - e) });
+    return s === "inject" ? { finish: y, header: M(r.traceId, c.spanId) } : { finish: y };
+  }
+  /**
+   * §6.5's ladder above the `injected_*` split, in table order — the precedence *is* the
+   * order of these returns. `undefined` means the attribute is omitted entirely: absent
+   * means not traced, which is the honest report for a consumer who never opted in and for
+   * a sampled-out session (which injects no header at all, not a `flags=00` id).
+   */
+  decide(e) {
+    if (!(this.allowlist.size === 0 || !e.sampled))
+      return U(this.allowlist, e.url) ? e.noCors ? "skipped_no_cors" : e.consumerTraceparent != null ? S(e.consumerTraceparent) ? "adopted" : "skipped_consumer_set" : "inject" : "skipped_off_allowlist";
+  }
+  /**
+   * Tier 2 — annotation-only (§6.3): join the trace without occupying a span. No
+   * `span.id`, no parent, no duration, and **no minting** — §6.2 lists the four events
+   * that mint and these are not among them, so an untraced crash carries no trace keys
+   * rather than inventing a root nothing else will ever join.
+   */
+  annotate(e = Date.now()) {
+    const t = this.liveRoot(e);
+    return t ? {
+      "trace.id": t.traceId,
+      "rum.action.id": t.spanId,
+      "trace.root_type": t.rootType
+    } : {};
+  }
+  /**
+   * Drop the carrier. Background clears it on both builds, so a resumed app's first fetch
+   * mints its own root rather than joining an action from before the user left (§6.2);
+   * session rotation clears it because `trace.id` never spans a `session.id` (§6.6).
+   */
+  clear() {
+    this.root = void 0;
+  }
+  /**
+   * Retire the launch root and mint a replacement, keeping the *reported* launch time —
+   * the process really did start then. For a session rotation that lands **before**
+   * `app.start`, which is the expired-record cold launch and therefore §4.3's most common
+   * path of all.
+   *
+   * Clearing alone would not do: `app.start` reports the launch root at any age, so its
+   * root row would ship under the **new** session while the initial `view` it fathered
+   * shipped under the **old** one. `trace.id` would span a `session.id` (§6.6, invariant 2)
+   * and `GROUP BY rum.action.id` would never reassemble the launch envelope. Re-minting
+   * keeps the retired trace wholly inside the retired session.
+   *
+   * ⚠ The retired trace then has children and no root row — the initial `view` row is a
+   * rootless child. That is the same condition process death already produces by design
+   * (a killed view emits nothing), and it is the cheaper of the two wrongs.
+   */
+  restartLaunchRoot() {
+    this.launch = this.mint("launch", Date.now(), this.launch.spanStartMs);
+  }
+  /**
+   * Join the live root, or mint one of `mintAs`. A span's *start* extends the root.
+   *
+   * `attribution` is read **before** `liveRoot()` drops an expired carrier, which is the
+   * only place the two unattributed causes are still distinguishable: a carrier that just
+   * aged out is `injected_expired` (context lost), no carrier at all is
+   * `injected_unattributed` (no action) — the split §6.5 asks the backend to keep.
+   */
+  attach(e, t) {
+    const s = this.root !== void 0, r = this.liveRoot(t);
+    return r ? (r.lastTouch = t, { root: r, isRoot: !1, attribution: "injected_attributed" }) : {
+      root: this.mint(e, t, t),
+      isRoot: !0,
+      attribution: s ? "injected_expired" : "injected_unattributed"
+    };
+  }
+  mint(e, t, s) {
+    const r = {
+      traceId: W(),
+      spanId: N(),
+      rootType: e,
+      startedAt: t,
+      spanStartMs: s,
+      lastTouch: t
+    };
+    return this.root = r, r;
+  }
+  /**
+   * The carrier if it is still live, dropping it otherwise. Both boundaries are strict —
+   * a root sitting exactly on one has not crossed it — matching the session boundaries.
+   *
+   * A **negative** delta is clamped to expired (§6.7): `Date.now()` can move backwards on
+   * an NTP correction, and reading that as "fresh" would hold one root open indefinitely.
+   */
+  liveRoot(e) {
+    const t = this.root;
+    if (!t) return;
+    const s = e - t.lastTouch, r = e - t.startedAt;
+    if (s < 0 || r < 0 || s > j || r > B) {
+      this.root = void 0;
+      return;
+    }
+    return t;
+  }
+}
+function l(i, e, t) {
+  const s = e ? i.spanId : N();
+  return {
+    spanId: s,
+    keys: {
+      "trace.id": i.traceId,
+      "span.id": s,
+      ...e ? {} : { "parent.span.id": i.spanId },
+      "rum.action.id": i.spanId,
+      "trace.root_type": i.rootType,
+      "span.start_time": new Date(t).toISOString()
+    }
+  };
+}
+class J {
+  constructor(e = 20) {
+    this.max = e, this.items = [];
+  }
+  add(e) {
+    this.items.push(e), this.items.length > this.max && this.items.shift();
+  }
+  list() {
+    return [...this.items];
+  }
+  toJSON() {
+    return JSON.stringify(this.items);
+  }
+}
+const X = /* @__PURE__ */ new Set([
+  // `session.sequence` is not in the contract's §3.6 list, which names only `event.sequence`.
+  // Both are transmission ordinals with no scrubbing use case: (session.id, session.sequence)
+  // orders a session's batches (#92) and (session.id, event.sequence) is the backend's dedup
+  // key (#94, §2.4) — a hook that could delete either would break the thing it keys.
+  //
+  // `event.sequence` is stamped in `enqueue()` *after* this hook runs, so on the way in it is
+  // absent and the re-stamp is a no-op; it is listed because the hook must not be able to
+  // forge one, and because a re-run over an already-stamped event must leave it alone.
+  "session.id",
+  "session.start_time",
+  "session.sequence",
+  "event.sequence",
+  "device.platform",
+  "trace.id",
+  "span.id",
+  "parent.span.id",
+  "rum.action.id",
+  "view.id"
+]), k = (i) => X.has(i) || i.startsWith("sdk.") || i.startsWith("app."), m = "device.id";
+function Y(i, e) {
+  let t;
+  try {
+    t = e({ ...i, attributes: { ...i.attributes } });
+  } catch (s) {
+    return o.warn("Telemetry: beforeSend threw — event dropped", s), { kind: "failed" };
+  }
+  return t === null ? { kind: "dropped" } : typeof t != "object" ? (o.warn("Telemetry: beforeSend returned a non-event — event dropped", t), { kind: "failed" }) : { kind: "kept", event: Q(i, t) };
+}
+function Q(i, e) {
+  const t = {};
+  for (const [a, n] of Object.entries(e.attributes ?? {}))
+    k(a) || (t[a] = n);
+  for (const [a, n] of Object.entries(i.attributes ?? {}))
+    k(a) && (t[a] = n);
+  const s = t[m];
+  if (typeof s != "string" || s === "") {
+    const a = i.attributes?.[m];
+    a === void 0 ? delete t[m] : t[m] = a;
+  }
+  const r = {
+    type: i.type,
+    timestamp: i.timestamp,
+    attributes: t
+  };
+  return i.eventName !== void 0 && (r.eventName = i.eventName), i.metricName !== void 0 && (r.metricName = i.metricName), i.type === "metric" && (r.value = e.value ?? i.value), r;
+}
+function q(i) {
+  try {
+    return JSON.stringify(i) ?? void 0;
+  } catch {
+    return;
+  }
+}
+const G = 255, Z = 255, ee = 50, T = 64, A = 64, p = 255;
+let E = !1;
+function f(i, e) {
+  if (typeof i != "string") return;
+  const t = i.slice(0, e);
+  return t.length ? t : void 0;
+}
+function te(i) {
+  if (i == null) return;
+  if (typeof i == "number" || typeof i == "boolean") return i;
+  if (typeof i == "string") return i.slice(0, p) || void 0;
+  const e = q(i);
+  return e === void 0 ? void 0 : e.slice(0, p) || void 0;
+}
+function se(i) {
+  const e = {};
+  if (!i) return e;
+  const t = f(i.fullName, G), s = f(i.email, Z), r = f(i.phone, ee);
+  t !== void 0 && (e["user.name"] = t), s !== void 0 && (e["user.email"] = s), r !== void 0 && (e["user.phone"] = r);
+  let a = 0, n = 0;
+  for (const h of Object.keys(i.customAttributes || {})) {
+    if (h.length > A || n >= T) {
+      a++;
+      continue;
+    }
+    const c = te(i.customAttributes[h]);
+    if (c === void 0) {
+      a++;
+      continue;
+    }
+    e[`user.custom.${h}`] = c, n++;
+  }
+  return a > 0 && (e["user.custom_dropped"] = a, x() && !E && (E = !0, console.warn(
+    `[edge-telemetry] identify(): ${a} custom attribute(s) dropped. user.custom.* is bounded at ${T} keys, ${A}-char keys and ${p}-char values; unserializable values are dropped.`
+  ))), e;
+}
+const ie = "4.0.0", re = (i) => i ? `react-native-${i}` : "react-native", ne = ie, ae = 1800 * 1e3, oe = 14400 * 1e3, he = 8, ce = 500, v = (i) => i.attributes?.["event.sequence"] ?? -1, P = (i) => i === "app.crash" || i === "app.error";
+function de(i) {
+  const e = i.findIndex((t) => t.eventName !== "app.crash");
+  return e === -1 ? 0 : e;
+}
+const R = "telemetry_device_id", D = "telemetry_session", ue = 255, le = /* @__PURE__ */ new Set([
+  "session.started",
+  "session.finalized",
+  "app_lifecycle",
+  "navigation",
+  "screen.duration",
+  "http.request",
+  "network_change",
+  "user.profile.update",
+  "custom_event",
+  "app.crash",
+  "view",
+  // ⚠ `app.error` needs backend allowlist sign-off before it ships (#100, §4.7).
+  "app.error",
+  // §4.6/#102 — replaces `user.interaction`, which is off the list as of v4. The
+  // `rum_ui_interactions` columns are already built; the name still needs sign-off.
+  "ui.interaction",
+  // ⚠ `app.start` needs backend allowlist sign-off before it ships (#98, §4.3/§6.2) — an
+  // unlisted eventName is dropped on ingest. It is listed here, so it is being emitted.
+  "app.start",
+  "frame_render_time",
+  "memory_usage",
+  "LCP",
+  "FCP",
+  "CLS",
+  "INP",
+  "TTFB"
+  // ⚠ `page_load`, `resource_timing` and `long_task` are **retired, not deferred**
+  // (§10.2, #109) — as `user.interaction` was in #102, four in total for a net-zero v4.
+  // Do not add them back: `page_load`'s job is done three ways over (`view` +
+  // `view.loading_time` + the vitals), `resource_timing` would blow the 500-event queue on
+  // one asset-heavy view for a namespace with no column, and `long_task`'s only APIs are
+  // Chromium-only while `frame_render_time` detects jank on every runtime. A name off this
+  // list is rewritten to `custom_event`, so all four are unreachable, not merely unused.
+]), me = {
+  frame_render_time: "ms",
+  memory_usage: "MB",
+  LCP: "ms",
+  FCP: "ms",
+  INP: "ms",
+  TTFB: "ms",
+  CLS: "score"
+}, fe = /* @__PURE__ */ new Set(["app.crash", "app.error", "custom_event"]);
+function ve(i) {
+  return i === void 0 ? 1 : !Number.isFinite(i) || i < 0 || i > 1 ? (o.warn(`Telemetry: sessionSampleRate must be a number in [0,1] — got ${i}; using 1`), 1) : i;
+}
+class Ie {
+  constructor(e) {
+    this.queue = [], this.intervalId = null, this.userId = void 0, this.deviceIdEphemeral = !1, this.userProfile = void 0, this.eventCount = 0, this.breadcrumbs = new J(20), this.sessionSequence = 0, this.eventSequence = 0, this.sessionEventCount = 0, this.errorCount = 0, this.hookDropped = 0, this.hookFailed = 0, this.eventsDropped = 0, this.crashPersistedThrough = -1, this.appStartEmitted = !1, this.sender = e?.sender, this.batchSize = e?.batchSize ?? 50, this.flushIntervalMs = e?.flushIntervalMs ?? 3e4, this.endpoint = e?.endpoint, this.platform = e?.platform, this.store = e?.store ?? V({ unavailable: !0 }), this.beforeSend = e?.beforeSend, this.buildId = typeof e?.buildId == "string" && e.buildId !== "" ? e.buildId : void 0, this.configuredSampleRate = ve(e?.sessionSampleRate), this.sampleRate = this.configuredSampleRate, this.sampled = this.rollSample(), this.sessionId = e?.sessionId ?? this.generateSessionId(), e?.userId && this.setUserId(e.userId), this.sessionStart = Date.now(), this.sdkVersion = e?.sdkVersion ?? ne, this.sender?.replayFailed && this.sender.replayFailed().catch((t) => {
+      o.warn("Telemetry replay failed Telemetry class:", t);
+    }), this.flushIntervalMs > 0 && (this.intervalId = setInterval(() => this.flush().catch(() => {
+    }), this.flushIntervalMs)), this.navigationTracker = new F(this), this.screens = new L(this), this.deprecatedScreenFeeds = e?.deprecatedScreenFeeds ?? !0, this.trace = new K(e?.traceLaunchStart, e?.traceHostAllowlist), this.views = new $(this), this.deviceInfoHandler = e?.deviceInfoHandler ?? {
+      start: async () => Promise.resolve(),
+      collect: async () => Promise.resolve({
+        app: { name: "", version: "" },
+        device: { platform: "" }
+      })
+    }, this.networkInfoHandler = e?.networkInfoHandler ?? {
+      start: async () => Promise.resolve({}),
+      collect: async () => Promise.resolve({})
+    };
+  }
+  // ---------- Session & User APIs ----------
+  /**
+   * §4.7 — report a handled error. Accepts `unknown` on purpose: half of real `catch`
+   * blocks receive a string or an axios rejection object, and a consumer should not have
+   * to prove to TypeScript that it is an `Error` before reporting it.
+   *
+   * Emits `app.error`, **never** `app.crash`. There is deliberately no public path to
+   * `app.crash` — a consumer's own code must not be able to manufacture rows in the one
+   * table an unfiltered crash-free rate is read from.
+   *
+   * `source` is SDK-internal (`captureConsole` passes `"console"`); the public wrappers
+   * forward two arguments, so a consumer can only ever produce `"reported"`. Routing the
+   * console path through here rather than through `log()` directly is what keeps the
+   * `error.fatal` rule in one place.
+   */
+  captureError(e, t, s = "reported") {
+    const r = this.isNativePlatform() ? { fatal: !1 } : {};
+    return this.log("app.error", { ...t, ...z(s, e, r) });
+  }
+  /**
+   * Extend the breadcrumb trail without emitting anything. §4.7 demotes `console.warn` to
+   * exactly this — React's dev-mode warnings were the bulk of v3's `app.crash` volume.
+   *
+   * SDK-internal: `public` only so `adapters/crashCapture.ts` can reach it. Not on
+   * `TelemetryBase` and not part of the consumer API — a host app that wants a trail entry
+   * should `log()` an event, which extends the trail anyway.
+   */
+  addBreadcrumb(e, t) {
+    this.breadcrumbs.add({ ...t, name: e, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  trackErrors(e, t) {
+    this.crashHandler = e, e.attach(t).catch((s) => {
+      o.warn("Telemetry crashHandler attach failed:", s);
+    });
+  }
+  getDeviceInfo(e) {
+    this.deviceInfoHandler = e, e.start(this).catch((t) => {
+      o.warn("Telemetry deviceInfo tracking start failed:", t);
+    });
+  }
+  getNetworkInfo(e) {
+    this.networkInfoHandler = e, e.start(this).catch((t) => {
+      o.warn("Telemetry networkInfoHandler start failed:", t);
+    });
+  }
+  trackFrameDrops(e) {
+    this.frameDropsHandler = e, e.start().catch((t) => {
+      o.warn("Telemetry frameDropsHandler start failed:", t);
+    });
+  }
+  trackNetworkRequests(e) {
+    this.networkHandler = e, e.start().catch((t) => {
+      o.warn("Telemetry networkHandler start failed:", t);
+    });
+  }
+  trackMemoryUsage(e) {
+    this.memoryHandler?.stop?.(), this.memoryHandler = e, e.start().catch((t) => {
+      o.warn("Telemetry memoryHandler start failed:", t);
+    });
+  }
+  autoTrackNavigation(e) {
+    this.navigationHandler = e, e?.start().catch((t) => {
+      o.warn("Telemetry navigationHandler start failed:", t);
+    });
+  }
+  /**
+   * The per-session sample roll (§3.6). Never per-event: per-event sampling punches
+   * holes that desynchronise the per-view counters by a random factor per view.
+   *
+   * `Math.random()` is deliberate here where `randomHex` refuses it — this decides one
+   * boolean that dies with the session, not an id that persists forever, and a biased
+   * PRNG costs a fraction of a percent of sample accuracy rather than a permanent
+   * identity collision.
+   */
+  rollSample() {
+    return Math.random() < this.sampleRate;
+  }
+  /** §3.3 / §4.7's platform split, from the entry's declared `platform` opt — never a global. */
+  isNativePlatform() {
+    return this.platform === "ios" || this.platform === "android";
+  }
+  generateSessionId() {
+    const e = `session_${Date.now()}_${u(16)}`;
+    return this.platform ? `${e}_${this.platform}` : e;
+  }
+  setSessionId(e) {
+    this.sessionId = e, this.sessionStart = Date.now();
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Freeze the identity a deferred row must report (§4.6). Read **synchronously at the
+   * moment the thing happened**, so a `log()` that lands after a route change or a session
+   * rotation still books the click where it occurred.
+   */
+  snapshot(e) {
+    return {
+      at: e,
+      viewId: this.views.id,
+      sessionId: this.sessionId,
+      sessionStart: this.sessionStart
+    };
+  }
+  /** Collector endpoint, so fetch/XHR adapters can skip self-capturing the SDK's own POST. */
+  getEndpoint() {
+    return this.endpoint;
+  }
+  /**
+   * Sampling stays **session-level** (§6.5): an unsampled session injects no header at
+   * all — not a `flags=00` id. Read by the interceptors, which sit outside `log()`'s own
+   * sampled-out early return and so need the decision directly.
+   */
+  isSampled() {
+    return this.sampled;
+  }
+  // ---------- Session lifecycle (#29) ----------
+  /**
+   * The entry's one call at init (§4.2): resume the durable session when the gap is
+   * inside the idle window, otherwise close the stale one out and start fresh.
+   *
+   * Process death, tab close, hard reload and bfcache restore all land here, and all
+   * four **resume** — which is why a resumed session must not re-emit `session.started`
+   * (§4.1), or `COUNT(session.started)` stops equalling session count.
+   */
+  async resumeOrStartSession() {
+    await this.hydrateAndAnnounce(), await this.emitAppStart();
+  }
+  async hydrateAndAnnounce() {
+    const e = await this.hydrateSession();
+    if (e.kind === "resumed") return;
+    if (e.kind === "expired") {
+      await this.rotateSession(e.reason);
+      return;
+    }
+    if (this.lastActivity === void 0) {
+      await this.startSession("launch");
+      return;
+    }
+    const t = this.expiryReason(Date.now());
+    t && await this.rotateSession(t);
+  }
+  /**
+   * `app.start` (§4.3/§6.2): once per process, a **root** of `trace.root_type = launch`,
+   * carrying the launch root minted in the constructor. Idempotent because the web build
+   * re-runs `resumeOrStartSession()` on a bfcache restore, which is a resumed process and
+   * not a new one.
+   */
+  async emitAppStart() {
+    this.appStartEmitted || (this.appStartEmitted = !0, await this.log("app.start", this.trace.launchRootAttributes()));
+  }
+  /**
+   * Read the durable record and adopt it. Adoption happens even when the session has
+   * expired: `session.finalized` has to ship under the *old* `session.id` and
+   * `session.start_time` before the fresh one takes over.
+   */
+  async hydrateSession() {
+    const e = await this.store.get(D);
+    if (e.status === "unavailable")
+      return o.warn("Telemetry: session storage unavailable — this session cannot be resumed"), { kind: "nothing" };
+    if (e.status === "miss") return { kind: "nothing" };
+    let t;
+    try {
+      t = JSON.parse(e.value);
+    } catch {
+      return { kind: "nothing" };
+    }
+    if (typeof t?.id != "string" || typeof t.start != "number" || typeof t.lastActivity != "number") return { kind: "nothing" };
+    this.sessionId = t.id, this.sessionStart = t.start, this.lastActivity = t.lastActivity, this.sessionSequence = t.sequence ?? 0, this.eventSequence = t.eventSequence ?? 0, this.sessionEventCount = t.eventCount ?? 0, this.errorCount = t.errorCount ?? 0, typeof t.sampled == "boolean" && Number.isFinite(t.sampleRate) && t.sampleRate >= 0 && t.sampleRate <= 1 && (this.sampled = t.sampled, this.sampleRate = t.sampleRate);
+    const s = this.expiryReason(Date.now());
+    return s ? { kind: "expired", reason: s } : { kind: "resumed" };
+  }
+  /**
+   * Which boundary, if any, the current session has crossed. Idle is checked first:
+   * when a long session has also gone quiet, the reason it ended is that the user left.
+   *
+   * Inert until `lastActivity` is set, so a bare `new Telemetry()` that never started a
+   * session never rotates one.
+   */
+  expiryReason(e) {
+    if (this.lastActivity !== void 0) {
+      if (e - this.lastActivity > ae) return "idle";
+      if (e - this.sessionStart > oe) return "max_duration";
+    }
+  }
+  /**
+   * Write the session through the `Store` so the next process can resume it.
+   *
+   * ponytail: one write per event. Web's is a synchronous `localStorage` write; native's
+   * is an AsyncStorage round-trip — debounce here if it ever shows up in a trace.
+   */
+  async persistSession() {
+    const e = {
+      id: this.sessionId,
+      start: this.sessionStart,
+      lastActivity: this.lastActivity ?? this.sessionStart,
+      sequence: this.sessionSequence,
+      eventSequence: this.eventSequence,
+      eventCount: this.sessionEventCount,
+      errorCount: this.errorCount,
+      sampled: this.sampled,
+      sampleRate: this.sampleRate
+    };
+    (await this.store.set(D, JSON.stringify(e))).status === "unavailable" && o.log("Telemetry: session not persisted (store unavailable)");
+  }
+  /** Emit session.started for the current session. */
+  async startSession(e) {
+    this.lastActivity = Date.now(), await this.persistSession(), await this.log("session.started", {
+      "session.reason": e,
+      // §4.1, count only — never the hosts (#99). Ships on every session so a zero is
+      // legible as "nobody opted in" rather than as a stripped header.
+      "sdk.trace_allowlist_size": this.trace.allowlistSize()
+    });
+  }
+  /**
+   * Finalize the current session: journey summary + sdk.error_count, then an immediate flush.
+   *
+   * The backend discards `duration_ms` and `event_count` and derives both (§4.2) — they
+   * stay on the wire because the event survives as the carrier for `session.reason` and
+   * `sdk.error_count`, neither of which is derivable. Duration is stamped from
+   * `lastActivity`, never `now`: a lazily-detected rotation must report 2 minutes of use,
+   * not the 6 idle hours that followed it.
+   */
+  async finalizeSession(e) {
+    await this.log("session.finalized", {
+      "session.duration_ms": Math.max(0, (this.lastActivity ?? this.sessionStart) - this.sessionStart),
+      "session.event_count": this.sessionEventCount,
+      "sdk.error_count": this.errorCount,
+      "session.reason": e
+    }), await this.flush();
+  }
+  /** Begin a fresh session: new id/start, reset per-session counters, emit session.started. */
+  async newSession(e) {
+    this.sessionId = this.generateSessionId(), this.sessionStart = Date.now(), this.sessionSequence = 0, this.eventSequence = 0, this.crashPersistedThrough = -1, this.sessionEventCount = 0, this.errorCount = 0, this.sampleRate = this.configuredSampleRate, this.sampled = this.rollSample(), this.appStartEmitted ? this.trace.clear() : this.trace.restartLaunchRoot(), await this.views.beginView("session_rotation"), await this.startSession(e);
+  }
+  /** Boundary rotation: finalize the old session then start a fresh one (the pair). */
+  async rotateSession(e) {
+    await this.views.endView(), await this.finalizeSession(e), await this.newSession(e);
+  }
+  /** Truncated at source (§3.2): the collector caps at 255 and we must not be the one over. */
+  setUserId(e) {
+    this.userId = e ? e.slice(0, ue) : void 0;
+  }
+  getUserId() {
+    return this.userId;
+  }
+  /**
+   * The SDK-owned `device.id` (§3.2/§3.3): self-minted, written through the `Store`,
+   * uninstall-scoped, stable across process restarts, and never rotated by login,
+   * logout or a profile clear.
+   *
+   * The platform suffix is the entry's (ios|android|web), not the device-info adapter's:
+   * this id is persisted forever, so it must not depend on a call that can throw on first run.
+   *
+   * `getUniqueId()` is deliberately not used — it already carries two lifetimes on RN
+   * alone (ANDROID_ID survives reinstall, identifierForVendor does not), so one identity
+   * column would mean two things.
+   *
+   * When the Store reports `unavailable` — incognito, a partitioned iframe, ITP
+   * eviction, a full disk — the id lives for one process only and `device.id_ephemeral`
+   * rides the Context block to say so, because that population is otherwise
+   * indistinguishable from real installs and reads as traffic growth.
+   */
+  async getDeviceId() {
+    return this.deviceIdPromise ??= (async () => {
+      const e = await this.store.get(R);
+      if (e.status === "hit") return e.value;
+      const t = this.platform ? `_${this.platform}` : "", s = `device_${Date.now()}_${u(16)}${t}`, r = await this.store.set(R, s);
+      return this.deviceIdEphemeral = e.status === "unavailable" || r.status === "unavailable", s;
+    })(), this.deviceIdPromise;
+  }
+  // ---------- User Profile Management ----------
+  /**
+   * Set complete user profile information
+   */
+  setUserProfile(e) {
+    const t = Date.now(), s = !this.userProfile || e.userId && e.userId !== this.userProfile.userId;
+    this.userProfile = {
+      ...this.userProfile,
+      ...e,
+      updatedAt: t,
+      ...s && { createdAt: t }
+    }, e.userId ? (this.setUserId(e.userId), this.userProfile.userId = this.userId) : this.userProfile && !this.userProfile.userId && (this.userProfile.userId = this.userId), o.log("Telemetry: User profile updated", this.userProfile);
+  }
+  /**
+   * EdgeRum-style identify(): record the host-app profile and emit the one event that
+   * carries it — `user.profile.update` (§4.10, #107). The PII is no longer on the
+   * Context block of every event.
+   *
+   * `userId` is optional and new in v4: the one call that sends a profile should also
+   * set the key that profile attaches to, since `user.id` is consumer-supplied (§3.2)
+   * and an unkeyed profile has nothing to upsert on. Omitting it leaves `user.id`
+   * exactly as it was — identify never mints one.
+   */
+  async identify(e) {
+    e.userId !== void 0 && this.setUserId(e.userId), this.setUserProfile({
+      ...e.name !== void 0 ? { fullName: e.name } : {},
+      ...e.email !== void 0 ? { email: e.email } : {},
+      ...e.phone !== void 0 ? { phone: e.phone } : {},
+      ...e.avatar !== void 0 ? { avatar: e.avatar } : {},
+      ...e.customAttributes !== void 0 ? { customAttributes: e.customAttributes } : {}
+    }), await this.log("user.profile.update", se(this.userProfile));
+  }
+  /**
+   * Set user details with individual parameters
+   */
+  setUserDetails(e) {
+    this.setUserProfile(e);
+  }
+  /**
+   * Update specific user profile fields
+   */
+  updateUserProfile(e) {
+    if (!this.userProfile) {
+      this.setUserProfile(e);
+      return;
+    }
+    this.userProfile = {
+      ...this.userProfile,
+      ...e,
+      updatedAt: Date.now()
+    }, o.log("Telemetry: User profile updated", this.userProfile);
+  }
+  /**
+   * Get current user profile
+   */
+  getUserProfile() {
+    return this.userProfile;
+  }
+  /**
+   * Clear user profile data
+   */
+  clearUserProfile() {
+    this.userProfile = void 0, this.userId = void 0, o.log("Telemetry: User profile cleared");
+  }
+  /**
+   * Set user name (convenience method)
+   */
+  setUserName(e, t, s) {
+    this.setUserProfile({
+      fullName: e,
+      firstName: t,
+      lastName: s
+    });
+  }
+  /**
+   * Set user contact info (convenience method)
+   */
+  setUserContact(e, t) {
+    this.setUserProfile({
+      email: e,
+      phone: t
+    });
+  }
+  // ---------- Logging APIs ----------
+  /**
+   * Log a named event. Keeps existing signature compatibility.
+   * Automatically attaches userId and sessionId to every queued event.
+   */
+  async log(e, t, s) {
+    this.eventCount++;
+    let r = !1, a = !1;
+    if (!e.startsWith("session.") && e !== "view") {
+      const n = Date.now(), h = this.expiryReason(n);
+      h && await this.rotateSession(h), this.lastActivity = n, this.sessionEventCount++, P(e) && this.errorCount++, r = !0;
+    }
+    if (this.sampled) {
+      const n = le.has(e), h = n ? e : "custom_event", c = await this.collectContext(t);
+      n || (c["event.name"] = e), fe.has(h) && Object.assign(c, this.trace.annotate()), h === "app.crash" ? (c["error.breadcrumbs"] = this.breadcrumbs.toJSON(), a = !0) : this.breadcrumbs.add({ name: h, timestamp: (/* @__PURE__ */ new Date()).toISOString() }), P(h) ? this.views.countError() : h === "ui.interaction" && this.views.countAction(), s && (c["view.id"] = s.viewId, c["view.name"] = this.views.nameOf(s.viewId), c["session.id"] = s.sessionId, c["session.start_time"] = new Date(s.sessionStart).toISOString()), this.enqueue({
+        type: "event",
+        eventName: h,
+        timestamp: new Date(s?.at ?? Date.now()).toISOString(),
+        attributes: c
+      }), o.log("Telemetry queued event:", e, "Queue size:", this.queue.length), o.log("Event attributes:", c);
+    }
+    r && await this.persistSession(), a ? await this.flushCrash() : this.queue.length >= this.batchSize && this.flush();
+  }
+  /**
+   * The crash path (§2 / §9.4): persist the whole queue, then send **one** batch reordered
+   * so the crash rides in it. Not a drain — a dying process gets one round trip.
+   *
+   * ⚠ The web/native asymmetry is real and is not fixed here. On web the `Store` is
+   * synchronous `localStorage`, so the persist has *landed* by the time the next line runs
+   * and the loss window closes. On native it is an AsyncStorage round-trip that a SIGKILL
+   * can outrun, so the window only narrows. Awaiting harder does not change that; the
+   * asymmetry is the `Store` port's whole point (`core/store.ts`).
+   *
+   * The persisted copy is a safety copy, not a handoff: the queue is left intact, because
+   * an `app.crash` is not always fatal — `window.onerror` fires and the page keeps running
+   * — and the process usually lives on. A successful send therefore
+   * leaves a duplicate on disk to replay next launch — which is what `event.sequence` and
+   * the backend's `(session_id, event_sequence)` dedup exist for (§2.4).
+   *
+   * *One* duplicate. Each row is written at most once by this path, watermarked on
+   * `event.sequence`: a chatty app crash-flushes often, and re-persisting the whole queue
+   * each time would fill the store with copies of
+   * its own backlog and book `store_full` drops that are not loss — corrupting the very
+   * counter this change adds.
+   */
+  async flushCrash() {
+    if (!this.sender || this.queue.length === 0) return;
+    const e = (r) => r.eventName === "app.crash";
+    this.queue = [...this.queue.filter(e), ...this.queue.filter((r) => !e(r))];
+    const t = this.queue.filter((r) => v(r) > this.crashPersistedThrough);
+    if (t.length > 0 && this.sender.onFailure)
+      try {
+        this.recordDrop("store_full", await this.sender.onFailure(t)), this.crashPersistedThrough = Math.max(this.crashPersistedThrough, ...t.map(v));
+      } catch (r) {
+        o.warn("Telemetry: crash-path persist failed:", r);
+      }
+    const s = this.queue.splice(0, this.batchSize);
+    try {
+      await this.sender.send(s), await this.ackBatch();
+    } catch (r) {
+      const a = s.filter((n) => v(n) > this.crashPersistedThrough);
+      a.length > 0 && this.queue.unshift(...a), o.warn("Telemetry: crash-path send failed:", r);
+    }
+  }
+  /**
+   * Build the v3 Context block that rides on every event AND metric: the flattened
+   * device/network snapshot, the caller's data, identity + session + sdk fields, and the
+   * user profile. Shared by log() and logMetric() so both carry the identical iOS-clean set.
+   */
+  async collectContext(e) {
+    let t = {}, s = {};
+    try {
+      t = await this.deviceInfoHandler?.collect() || {};
+    } catch (n) {
+      o.warn("Telemetry: failed to fetch device info", n);
+    }
+    try {
+      s = await this.networkInfoHandler?.collect() || {};
+    } catch (n) {
+      o.warn("Telemetry: failed to fetch network info", n);
+    }
+    const r = await this.getDeviceId();
+    return {
+      // deviceInfo already namespaces its own keys (app.*, device.*) — flatten flat
+      ...this.flattenWithPrefix("", t),
+      ...this.flattenWithPrefix("network", s),
+      ...this.flattenWithPrefix("", e || {}),
+      // Identity keys land after caller data: `data` may override app./device./network.*
+      // but must never override these (§3.3).
+      // With the identity keys, not with deviceInfo's `app.*`: it is the symbolication
+      // join key, so a stray `log()` payload must not be able to shift which map a
+      // crash resolves against.
+      ...this.buildId ? { "app.build_id": this.buildId } : {},
+      "device.id": r,
+      ...this.deviceIdEphemeral ? { "device.id_ephemeral": !0 } : {},
+      // Omitted entirely on anonymous traffic (§3.2) — no "", no placeholder.
+      ...this.userId ? { "user.id": this.userId } : {},
+      // Denormalized onto every row (§4.5) so "errors by screen" needs no join. The id
+      // is the join key; the name is the view's current best, resolved here at log time
+      // by lookup on that id, so a row can never carry a name that disagrees with it.
+      "view.id": this.views.id,
+      "view.name": this.views.name,
+      "session.id": this.sessionId,
+      "session.start_time": new Date(this.sessionStart).toISOString(),
+      "session.sequence": this.sessionSequence,
+      // Extrapolation is arithmetic when the rate is on the row: it survives a
+      // consumer retuning mid-quarter, which config-in-a-spreadsheet does not.
+      "session.sample_rate": this.sampleRate,
+      // Monotonic and always present; the reason stays omitted until there is one,
+      // so `sdk.drop_reason IS NOT NULL` is a usable filter for "this install lost data".
+      "sdk.events_dropped": this.eventsDropped,
+      ...this.dropReason ? { "sdk.drop_reason": this.dropReason } : {},
+      "sdk.hook_dropped": this.hookDropped,
+      "sdk.hook_failed": this.hookFailed,
+      "sdk.platform": re(this.platform),
+      "sdk.version": this.sdkVersion
+    };
+  }
+  /**
+   * Emit a metric on the v3 `type:"metric"` path: { type, metricName, value, timestamp, attributes }.
+   * Carries the same Context block as events. Metrics are samples, not user actions, so they
+   * don't extend the breadcrumb trail and don't count as session activity — a periodic sampler
+   * (memory/frames) must not keep a session alive and defeat the 30-min idle rotation.
+   */
+  async logMetric(e, t, s) {
+    this.eventCount++;
+    const r = this.expiryReason(Date.now());
+    if (r && await this.rotateSession(r), !this.sampled) return;
+    const a = await this.collectContext(s), n = me[e];
+    n && (a["metric.unit"] = n), this.enqueue({
+      type: "metric",
+      metricName: e,
+      value: t,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      attributes: a
+    }), this.queue.length >= this.batchSize && this.flush();
+  }
+  /**
+   * The single enqueue point: neither the sample decision nor `beforeSend` can be
+   * bypassed by a future emit path, and the hook runs *before* the queue — which is
+   * what keeps scrubbed fields off disk when a send fails and the batch is persisted.
+   *
+   * The sample check is repeated by log()/logMetric() ahead of `collectContext()`, so
+   * a sampled-out session does no work per event; this one is the backstop that makes
+   * the guarantee structural rather than a convention two call sites happen to follow.
+   *
+   * The two counters are separate on purpose: "my volume is down 40%" has to
+   * distinguish *my rule is too broad* from *my rule is crashing*, and one merged
+   * counter answers neither.
+   */
+  enqueue(e) {
+    if (!this.sampled) return;
+    let t = e;
+    if (this.beforeSend) {
+      const s = Y(e, this.beforeSend);
+      if (s.kind === "failed") {
+        this.hookFailed++;
+        return;
+      }
+      if (s.kind === "dropped") {
+        this.hookDropped++;
+        return;
+      }
+      t = s.event;
+    }
+    (t.attributes ??= {})["event.sequence"] = this.eventSequence++, this.queue.push(t), this.capQueue();
+  }
+  /**
+   * Hold the in-memory queue at its cap (§9.4), booking what it costs.
+   *
+   * The count lands on the *next* event's Context block, not this one's — `collectContext()`
+   * has already run by the time we get here. That is §3.7's stated behaviour, not a bug.
+   */
+  capQueue() {
+    for (; this.queue.length > ce; )
+      this.queue.splice(de(this.queue), 1), this.recordDrop("queue_full");
+  }
+  /**
+   * Book dropped rows against the monotonic counter and the reason that shipped last.
+   * Takes `Sender.onFailure`'s return shape as-is — a sender with no cap returns nothing.
+   */
+  recordDrop(e, t = 1) {
+    !t || t <= 0 || (this.eventsDropped += t, this.dropReason = e);
+  }
+  flattenWithPrefix(e, t, s = 0) {
+    const r = {};
+    for (const a in t) {
+      if (!Object.prototype.hasOwnProperty.call(t, a)) continue;
+      const n = t[a], h = e ? `${e}.${a}` : a;
+      if (n !== void 0)
+        if (typeof n == "object" && n !== null && !Array.isArray(n) && s < he)
+          Object.assign(r, this.flattenWithPrefix(h, n, s + 1));
+        else if (typeof n == "object" && n !== null) {
+          const c = q(n);
+          c !== void 0 && (r[h] = c);
+        } else
+          r[h] = n;
+    }
+    return r;
+  }
+  /**
+   * Explicit metric helper (optional convenience) — routes through the v3 metric path.
+   */
+  recordMetric(e, t, s) {
+    return this.logMetric(e, t, s);
+  }
+  // ---------- Flush / Persistence ----------
+  // Retry + backoff live in the Sender (see sendWithRetry in web/native senders),
+  // which is also used by the standalone replay paths. flush() does a single send
+  // and, on failure, hands the batch to the sender to persist (or requeues it).
+  async flush() {
+    if (!this.sender || this.queue.length === 0) return;
+    const e = this.queue.splice(0, this.batchSize);
+    try {
+      await this.sender.send(e), await this.ackBatch();
+    } catch (t) {
+      if (this.sender.onFailure)
+        try {
+          this.recordDrop("store_full", await this.sender.onFailure(e));
+        } catch (s) {
+          this.queue.unshift(...e), o.warn("Sender.onFailure failed, requeued events:", s);
+        }
+      else
+        this.queue.unshift(...e);
+      throw o.error("Telemetry flush failed:", t), t;
+    }
+  }
+  /**
+   * Book an acknowledged (2xx) batch. `session.sequence` orders a session's batches (#29),
+   * and it is persisted because a resumed session restarting at 0 would emit duplicate
+   * (session.id, session.sequence) pairs and stop ordering anything (#92).
+   */
+  async ackBatch() {
+    this.sessionSequence++, await this.persistSession();
+  }
+  getQueue() {
+    return [...this.queue];
+  }
+  async shutdown() {
+    this.intervalId && clearInterval(this.intervalId), this.memoryHandler?.stop?.(), await this.flush();
+  }
+  // Screen tracking lives in ScreenTimingTracker (this.screens), the single timed API.
+  // Expose some internal counters (optional)
+  getEventCount() {
+    return this.eventCount;
+  }
+  /**
+   * A route change: the view boundary (§4.5) plus, on native only, the two deprecated
+   * feeds (§4.11). v3's two native screen paths were disjoint — `attachNavigation` never
+   * touched `inst.screens`, so a React Navigation consumer emitted `navigation` on every
+   * route change and never a single `screen.duration`. Unifying them here is what fixes
+   * that, which is why a *deprecated* event starts firing where it never has.
+   */
+  async recordRouteChange(e, t) {
+    this.currentScreen = t, this.deprecatedScreenFeeds && (await this.navigationTracker?.recordRouteChange(e, t), await this.screens.endScreen(e), this.screens.markStart(t)), await this.enterView(t, "route");
+  }
+  /**
+   * Feed the name ladder (§4.5.1). Rungs 1 and 2 arrive unnormalized; rung 3's caller
+   * normalizes before calling. Whether this re-stamps the current view or mints a
+   * successor is the ladder's decision, not the caller's.
+   */
+  async enterView(e, t) {
+    await this.views.navigate(e, t);
+  }
+}
+export {
+  R as DEVICE_ID_KEY,
+  D as SESSION_KEY,
+  Ie as Telemetry,
+  de as evictIndex,
+  P as isErrorName
+};
+//# sourceMappingURL=telemetry-ByDJIz_9.js.map