@keyframerdev/vitals 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1554 @@
+// src/index.ts
+import { createElement } from "react";
+import { View } from "react-native";
+
+// src/native.ts
+import { AccessibilityInfo, AppState, Platform } from "react-native";
+import { scheduleOnRN, scheduleOnUI } from "react-native-worklets";
+
+// ../protocol/src/vitals.ts
+var VITALS_FORMAT = "keyframer-vitals";
+var VITALS_VERSION = 1;
+var VITALS_ENDPOINT = "https://vitals.keyframer.dev";
+var VITALS_BUCKETS = [0, 1, 2, 3, 5, 9, 17, 33];
+var VITALS_FROZEN_MS = 700;
+var VITALS_WINDOW_MS = 10 * 60 * 1000;
+var VITALS_SESSION_GAP_MS = 30 * 1000;
+var VITALS_LIMITS = { screens: 40, sites: 200, worst: 10, images: 64, bytes: 32 * 1024, screenName: 64 };
+var VITALS_MAX_SESSIONS_PER_DAY = 3;
+var VITALS_DEFAULT_SAMPLE_RATE = 0.1;
+
+// src/collector.ts
+var SLACK_MS = 32;
+var LEAD_MS = 50;
+var MOUNT_MS = 500;
+var BURST = 6;
+var TOUCH_TAIL_MS = 1500;
+var SCROLL_TAIL_MS = 250;
+var MAX_WINDOWS = 100;
+var MAX_STARTS = 64;
+var MAX_SPANS = 16;
+var MAX_NAVS = 16;
+function bucketOf(missed) {
+  let b = 0;
+  for (let i = 1;i < VITALS_BUCKETS.length; i++)
+    if (missed >= VITALS_BUCKETS[i])
+      b = i;
+  return b;
+}
+var emptyThread = () => ({ frames: 0, hist: VITALS_BUCKETS.map(() => 0), frozen: 0, hitchMs: 0, idleFrames: 0, idleMissed: 0 });
+var siteId = (s) => s.key ?? refId(s.ref);
+function refId(r) {
+  switch (r.kind) {
+    case "source":
+      return `${r.file}:${r.line}:${r.column ?? 0}`;
+    case "hashed":
+      return `#${r.hash}`;
+    case "name":
+      return `name:${r.name}`;
+    case "native":
+      return `native:${r.image}:${r.offset}`;
+    case "jvm":
+      return `jvm:${r.className}.${r.method}:${r.line ?? 0}`;
+  }
+}
+var hzOf = (budget) => Math.round(1000 / budget);
+
+class Collector {
+  keepWorst;
+  screens = new Map;
+  sites = new Map;
+  windows = [];
+  starts = [];
+  touches = [];
+  scrolls = [];
+  navs = [];
+  shown = [];
+  before = "app";
+  worst = [];
+  touching = 0;
+  screen = "app";
+  fgSince = null;
+  fgMs = 0;
+  measuring = null;
+  measuredMs = 0;
+  latest = -Infinity;
+  hzFrames = new Map;
+  frameMs = { ui: 0, js: 0 };
+  reduceMotion = false;
+  reduceMotionSeen = false;
+  constructor(keepWorst = 5) {
+    this.keepWorst = keepWorst;
+  }
+  foreground(on, now) {
+    if (on && this.fgSince === null)
+      this.fgSince = now;
+    else if (!on && this.fgSince !== null) {
+      this.accrue(now);
+      this.fgSince = null;
+      this.measure(false, now);
+    }
+  }
+  setScreen(name, now, nav = true) {
+    if (name === this.screen && this.shown.length)
+      return;
+    this.accrue(now);
+    if (!this.shown.length)
+      this.before = this.screen;
+    this.screen = this.screenKey(name);
+    this.shown.push({ t: now, name: this.screen });
+    if (this.shown.length > MAX_NAVS)
+      this.before = this.shown.shift().name;
+    if (nav) {
+      this.navs.push({ t: now, name: this.screen });
+      if (this.navs.length > MAX_NAVS)
+        this.navs.shift();
+    }
+  }
+  setReduceMotion(on) {
+    this.reduceMotion = on;
+    if (on)
+      this.reduceMotionSeen = true;
+  }
+  animStart(info, now, ms, thread, eid = -1) {
+    const key = siteId(info);
+    const s = this.site(key, info);
+    s.runs++;
+    if (this.reduceMotion)
+      s.runsReduceMotion++;
+    s.screens.set(this.screen, (s.screens.get(this.screen) ?? 0) + 1);
+    const end = now + Math.max(0, ms);
+    s.activeMs += Math.max(0, end - Math.max(now, s.activeUntil));
+    s.activeUntil = Math.max(s.activeUntil, end);
+    this.windows.push({ key, info, start: now, end, eid });
+    if (this.windows.length > MAX_WINDOWS)
+      this.windows.splice(0, this.windows.length - MAX_WINDOWS);
+    this.starts.push({ t: now, key, thread });
+    if (this.starts.length > MAX_STARTS)
+      this.starts.shift();
+  }
+  consume(eid) {
+    const i = this.windows.findIndex((w2) => w2.eid === eid);
+    if (i < 0)
+      return;
+    const [w] = this.windows.splice(i, 1);
+    const s = this.sites.get(w.key);
+    if (s && s.runs > 0) {
+      s.runs--;
+      const n = (s.screens.get(this.screen) ?? 0) - 1;
+      if (n > 0)
+        s.screens.set(this.screen, n);
+      else
+        s.screens.delete(this.screen);
+      s.activeMs = Math.max(0, s.activeMs - (w.end - w.start));
+      if (s.runs === 0 && s.frames === 0)
+        this.sites.delete(w.key);
+    }
+    for (let j = this.starts.length - 1;j >= 0; j--) {
+      if (this.starts[j].key === w.key && this.starts[j].t === w.start) {
+        this.starts.splice(j, 1);
+        break;
+      }
+    }
+  }
+  touch(down, now) {
+    if (down) {
+      if (this.touching++ === 0)
+        this.pushSpan(this.touches, now, Infinity);
+    } else if (this.touching > 0 && --this.touching === 0) {
+      const last = this.touches[this.touches.length - 1];
+      if (last && last.end === Infinity)
+        last.end = now + TOUCH_TAIL_MS;
+    }
+  }
+  scroll(now) {
+    const last = this.scrolls[this.scrolls.length - 1];
+    if (last && now <= last.end + SCROLL_TAIL_MS)
+      last.end = Math.max(last.end, now);
+    else
+      this.pushSpan(this.scrolls, now, now);
+  }
+  measure(on, now) {
+    if (on && this.measuring === null)
+      this.measuring = now;
+    else if (!on && this.measuring !== null) {
+      this.measuredMs += Math.max(0, now - this.measuring);
+      this.measuring = null;
+    }
+  }
+  frame(thread, t, dt, budget) {
+    if (!(dt > 0) || !(budget > 0))
+      return;
+    const missed = Math.max(0, Math.round(dt / budget) - 1);
+    const hitch = Math.max(0, dt - budget);
+    const screenName = this.screenAt(t);
+    const screen = this.screenStats(screenName);
+    const st = screen.threads[thread] ??= emptyThread();
+    st.frames++;
+    st.hist[bucketOf(missed)]++;
+    if (dt >= VITALS_FROZEN_MS)
+      st.frozen++;
+    st.hitchMs += hitch;
+    const hz = hzOf(budget);
+    this.hzFrames.set(hz, (this.hzFrames.get(hz) ?? 0) + 1);
+    this.frameMs[thread] += dt;
+    if (t > this.latest)
+      this.latest = t;
+    const active = new Map;
+    for (const w of this.windows)
+      if (t >= w.start && t <= w.end + SLACK_MS)
+        active.set(w.key, w.info);
+    if (!active.size) {
+      st.idleFrames++;
+      st.idleMissed += missed;
+    }
+    const charged = [];
+    for (const [key, info] of active) {
+      const s = this.site(key, info);
+      s.frames++;
+      s.missed += missed;
+      s.hitchMs += hitch;
+      if (dt > s.worstMs)
+        s.worstMs = dt;
+      charged.push(s);
+    }
+    if (missed > 0)
+      this.considerWorst(thread, t, dt, missed, screenName, charged);
+    this.prune();
+  }
+  snapshot(now) {
+    this.accrue(now);
+    const gate = this.measuredMs + (this.measuring !== null ? Math.max(0, now - this.measuring) : 0);
+    const measuredMs = Math.min(this.fgMs, Math.max(gate, this.frameMs.ui, this.frameMs.js));
+    let targetHz = 60;
+    let best = -1;
+    let maxHz = 0;
+    for (const [hz, n] of this.hzFrames) {
+      if (n > best) {
+        best = n;
+        targetHz = hz;
+      }
+      if (hz > maxHz)
+        maxHz = hz;
+    }
+    return {
+      screens: [...this.screens.values()],
+      sites: [...this.sites.values()],
+      worst: [...this.worst],
+      foregroundMs: this.fgMs,
+      measuredMs,
+      targetHz,
+      maxHz: maxHz || targetHz,
+      reduceMotion: this.reduceMotionSeen
+    };
+  }
+  reset(now) {
+    this.accrue(now);
+    this.screens.clear();
+    this.sites.clear();
+    this.worst = [];
+    this.fgMs = 0;
+    this.measuredMs = 0;
+    if (this.measuring !== null)
+      this.measuring = now;
+    this.hzFrames.clear();
+    this.frameMs = { ui: 0, js: 0 };
+    this.reduceMotionSeen = this.reduceMotion;
+  }
+  clear() {
+    this.screens.clear();
+    this.sites.clear();
+    this.windows = [];
+    this.starts = [];
+    this.touches = [];
+    this.scrolls = [];
+    this.navs = [];
+    this.shown = [];
+    this.before = this.screen;
+    this.worst = [];
+    this.touching = 0;
+    this.fgMs = 0;
+    this.fgSince = null;
+    this.measuring = null;
+    this.measuredMs = 0;
+    this.hzFrames.clear();
+    this.frameMs = { ui: 0, js: 0 };
+    this.reduceMotionSeen = this.reduceMotion;
+  }
+  get currentScreen() {
+    return this.screen;
+  }
+  get foregroundMs() {
+    return this.fgMs;
+  }
+  foregroundAt(now) {
+    return this.fgMs + (this.fgSince !== null ? Math.max(0, now - this.fgSince) : 0);
+  }
+  accrue(now) {
+    if (this.fgSince === null)
+      return;
+    const dt = Math.max(0, now - this.fgSince);
+    this.fgMs += dt;
+    this.fgSince = now;
+    if (dt > 0)
+      this.screenStats(this.screen).ms += dt;
+  }
+  screenKey(name) {
+    if (this.screens.has(name) || this.screens.size < VITALS_LIMITS.screens - 1)
+      return name;
+    return "other";
+  }
+  screenStats(name) {
+    let s = this.screens.get(name);
+    if (!s)
+      this.screens.set(name, s = { name, ms: 0, threads: {} });
+    return s;
+  }
+  screenAt(t) {
+    for (let i = this.shown.length - 1;i >= 0; i--)
+      if (this.shown[i].t <= t)
+        return this.shown[i].name;
+    return this.shown.length ? this.before : this.screen;
+  }
+  site(key, info) {
+    let s = this.sites.get(key);
+    if (!s) {
+      s = { info, runs: 0, runsReduceMotion: 0, activeMs: 0, frames: 0, missed: 0, hitchMs: 0, worstMs: 0, screens: new Map, activeUntil: -Infinity };
+      this.sites.set(key, s);
+    }
+    return s;
+  }
+  pushSpan(list, start, end) {
+    list.push({ start, end });
+    if (list.length > MAX_SPANS)
+      list.shift();
+  }
+  open(list, t, tail) {
+    return list.some((s) => t >= s.start - 16 && t <= s.end + tail);
+  }
+  considerWorst(thread, t, dt, missed, screen, charged) {
+    if (this.worst.length >= this.keepWorst && dt <= this.worst[this.worst.length - 1].ms)
+      return;
+    const { cause, afterNavMs } = this.causeOf(thread, t, dt);
+    const w = { thread, ms: dt, missed, screen, sites: charged, cause, ...afterNavMs !== undefined ? { afterNavMs } : {} };
+    this.worst.push(w);
+    this.worst.sort((a, b) => b.ms - a.ms);
+    if (this.worst.length > this.keepWorst)
+      this.worst.length = this.keepWorst;
+  }
+  causeOf(thread, t, dt) {
+    let nav;
+    for (const n of this.navs)
+      if (n.t <= t)
+        nav = n.t;
+    if (nav !== undefined && t - nav <= MOUNT_MS)
+      return { cause: "screen-mount", afterNavMs: Math.round(t - nav) };
+    const from = t - dt - LEAD_MS;
+    const started = this.starts.filter((s) => s.t >= from && s.t <= t + 4);
+    if (new Set(started.map((s) => s.key)).size >= BURST)
+      return { cause: "burst" };
+    if (thread === "js" && started.some((s) => s.thread === "js"))
+      return { cause: "busy-start" };
+    if (!started.length && this.open(this.scrolls, t, SCROLL_TAIL_MS))
+      return { cause: "scroll" };
+    if (!started.length && this.open(this.touches, t, 0))
+      return { cause: "gesture" };
+    return { cause: "unknown" };
+  }
+  prune() {
+    const before = this.latest - 2000;
+    if (this.windows.length && this.windows[0].end + SLACK_MS < before)
+      this.windows = this.windows.filter((w) => w.end + SLACK_MS >= before);
+    while (this.touches.length > 1 && this.touches[0].end < before)
+      this.touches.shift();
+    while (this.scrolls.length > 1 && this.scrolls[0].end + SCROLL_TAIL_MS < before)
+      this.scrolls.shift();
+  }
+}
+var GATE_TAIL_MS = 250;
+
+class MotionGate {
+  until = -Infinity;
+  touching = 0;
+  note(end, now) {
+    const wasOpen = this.open(now);
+    if (end + GATE_TAIL_MS > this.until)
+      this.until = end + GATE_TAIL_MS;
+    return !wasOpen && this.open(now);
+  }
+  touch(down, now) {
+    const wasOpen = this.open(now);
+    if (down)
+      this.touching++;
+    else if (this.touching > 0 && --this.touching === 0)
+      this.note(now + TOUCH_TAIL_MS, now);
+    return !wasOpen && this.open(now);
+  }
+  open(now) {
+    return this.touching > 0 || now <= this.until;
+  }
+  closesAt() {
+    return this.touching > 0 ? Infinity : this.until;
+  }
+  reset() {
+    this.until = -Infinity;
+    this.touching = 0;
+  }
+}
+
+// src/mask.ts
+var MASKS = [
+  [/([?&#](?:access_?token|refresh_?token|id_?token|token|key|api_?key|secret|password|passwd|pwd|code|auth|session|sig|signature)=)[^&\s#"']+/gi, "$1[redacted]"],
+  [/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, "[id]"],
+  [/[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi, "[email]"],
+  [/\beyJ[\w-]{4,}\.[\w-]{4,}\.[\w-]*/g, "[token]"],
+  [/\b(Bearer|Basic|Token)\s+[\w\-.~+/]{8,}=*/gi, "$1 [token]"],
+  [/\b(?:kf|sk|pk|rk|ghp|gho|ghs|github_pat|xox[abpr]?|AKIA)[-_][\w-]{8,}/g, "[token]"],
+  [/\b(?=[\w-]*\d)(?=[\w-]*[A-Za-z])[\w-]{24,}\b/g, "[token]"],
+  [/\+?\(?\d{1,4}\)?(?:[ .-]\(?\d{2,4}\)?){2,}/g, "[number]"],
+  [/\d{4,}/g, "[number]"]
+];
+function maskText(text) {
+  let out = text;
+  for (const [re, by] of MASKS)
+    out = out.replace(re, by);
+  return out;
+}
+function screenName(raw) {
+  const s = typeof raw === "string" ? maskText(raw).trim() : "";
+  if (!s)
+    return "unknown";
+  return s.length > VITALS_LIMITS.screenName ? s.slice(0, VITALS_LIMITS.screenName) : s;
+}
+
+// src/encode.ts
+var r1 = (x) => Math.round(x * 10) / 10;
+var MAX_FOREGROUND = VITALS_WINDOW_MS + 60000;
+function hasData(s) {
+  return s.sites.some((x) => x.runs > 0 || x.frames > 0) || s.screens.some((x) => Object.values(x.threads).some((t) => t && t.frames > 0));
+}
+function encodeReport(snap, ctx) {
+  const ranked = snap.sites.filter((s) => s.runs > 0 || s.frames > 0).sort((a, b) => b.frames - a.frames || b.runs - a.runs);
+  let keep = Math.min(ranked.length, VITALS_LIMITS.sites);
+  for (;; ) {
+    const report = build(snap, ctx, ranked.slice(0, keep));
+    if (keep === 0 || JSON.stringify(report).length <= VITALS_LIMITS.bytes)
+      return report;
+    keep = Math.max(0, keep - Math.max(1, Math.ceil(keep / 10)));
+  }
+}
+function build(snap, ctx, kept) {
+  const screens = [];
+  const screenIndex = new Map;
+  const screenOf = (name) => {
+    let i = screenIndex.get(name);
+    if (i === undefined) {
+      if (screens.length >= VITALS_LIMITS.screens)
+        return screenIndex.get("other") ?? 0;
+      i = screens.length;
+      screenIndex.set(name, i);
+      screens.push({ name: screenName(name), ms: 0, threads: {} });
+    }
+    return i;
+  };
+  for (const s of snap.screens.slice(0, VITALS_LIMITS.screens)) {
+    const i = screenOf(s.name);
+    const threads = {};
+    for (const [t, st] of Object.entries(s.threads)) {
+      if (st && st.frames > 0)
+        threads[t] = { ...st, hist: [...st.hist], hitchMs: r1(st.hitchMs) };
+    }
+    screens[i] = { name: screenName(s.name), ms: Math.round(s.ms), threads };
+  }
+  const siteIndex = new Map;
+  const sites = kept.map((s, i) => {
+    siteIndex.set(s, i);
+    let where = "";
+    let most = -1;
+    for (const [name, n] of s.screens) {
+      if (n > most) {
+        most = n;
+        where = name;
+      }
+    }
+    const site = {
+      ref: s.info.ref,
+      ...s.info.key !== undefined ? { key: s.info.key } : {},
+      fn: s.info.fn,
+      component: s.info.component ?? null,
+      prop: s.info.prop ?? null,
+      screen: screenOf(where || snap.screens[0]?.name || "unknown"),
+      runs: s.runs,
+      activeMs: Math.round(Math.min(s.activeMs, MAX_FOREGROUND)),
+      frames: s.frames,
+      missed: s.missed,
+      hitchMs: r1(s.hitchMs),
+      worstMs: r1(s.worstMs)
+    };
+    if (ctx.collectReduceMotion)
+      site.runsReduceMotion = s.runsReduceMotion;
+    return site;
+  });
+  const worst = snap.worst.slice(0, ctx.worst ?? 5).map((w) => ({
+    thread: w.thread,
+    ms: r1(w.ms),
+    missed: w.missed,
+    screen: screenOf(w.screen),
+    sites: w.sites.map((s) => siteIndex.get(s)).filter((i) => i !== undefined),
+    cause: w.cause,
+    ...w.afterNavMs !== undefined ? { afterNavMs: w.afterNavMs } : {}
+  }));
+  const foregroundMs = Math.round(Math.min(snap.foregroundMs, MAX_FOREGROUND));
+  const measuredMs = Math.round(Math.min(snap.measuredMs, foregroundMs));
+  const state = {};
+  if (ctx.collectReduceMotion)
+    state.reduceMotion = snap.reduceMotion;
+  if (ctx.state?.lowPower !== undefined)
+    state.lowPower = ctx.state.lowPower;
+  if (ctx.state?.thermal !== undefined)
+    state.thermal = ctx.state.thermal;
+  const hz = ctx.display?.hz ?? snap.maxHz;
+  return {
+    format: VITALS_FORMAT,
+    version: VITALS_VERSION,
+    app: ctx.app,
+    sdk: ctx.sdk,
+    device: ctx.device,
+    display: { hz: Math.max(hz, snap.targetHz), ...ctx.display?.adaptive !== undefined ? { adaptive: ctx.display.adaptive } : {}, targetHz: snap.targetHz },
+    state,
+    session: { ...ctx.session, foregroundMs, measuredMs },
+    screens,
+    sites,
+    worst
+  };
+}
+
+// src/estimate.ts
+var isRef = (v) => !!v && typeof v === "object" && typeof v.$anim === "number";
+var num = (v, d) => typeof v === "number" && Number.isFinite(v) ? v : d;
+var cfg = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+function springSettleMs(c) {
+  if (typeof c.duration === "number")
+    return c.duration;
+  const k = num(c.stiffness, 100);
+  const d = num(c.damping, 10);
+  const m = num(c.mass, 1);
+  const w0 = Math.sqrt(k / m);
+  const zeta = d / (2 * Math.sqrt(k * m));
+  const decay = zeta < 1 ? zeta * w0 : w0 * (zeta - Math.sqrt(zeta * zeta - 1));
+  const s = decay > 0 ? 4 / decay : 2;
+  return Math.max(50, Math.min(5000, s * 1000));
+}
+function estimateMs(ev, byEid, depth = 0) {
+  if (depth > 12)
+    return 300;
+  if (typeof ev.durationMs === "number" && Number.isFinite(ev.durationMs))
+    return ev.durationMs;
+  const inner = (a) => {
+    if (!isRef(a))
+      return 300;
+    const e = byEid(a.$anim);
+    return e ? estimateMs(e, byEid, depth + 1) : 300;
+  };
+  const [a0, a1] = ev.args;
+  switch (ev.site.fn) {
+    case "withTiming":
+      return num(cfg(a1).duration, 300);
+    case "withSpring":
+      return springSettleMs(cfg(a1));
+    case "withDelay":
+      return num(a0, 0) + inner(a1);
+    case "withSequence":
+      return ev.args.reduce((s, a) => s + inner(a), 0);
+    case "withRepeat": {
+      const n = num(a1, 2);
+      return inner(a0) * (n > 0 ? n : 10);
+    }
+    case "withClamp":
+      return inner(a1);
+    case "withDecay":
+      return 1000;
+    case "CSS animation": {
+      const c = cfg(a0);
+      const n = typeof c.iterationCount === "number" ? c.iterationCount : c.iterationCount === "infinite" ? 10 : 1;
+      return num(c.delay, 0) + num(c.duration, 0) * n;
+    }
+    case "CSS transition":
+    case "entering":
+    case "exiting":
+    case "layout":
+      return num(cfg(a0).delay, 0) + num(cfg(a0).duration, 300);
+    case "withAnimation":
+    case "Transaction": {
+      const c = cfg(a1);
+      const speed = num(c.speed, 1) > 0 ? num(c.speed, 1) : 1;
+      const reps = c.repeatCount === "infinite" ? 10 : Math.max(1, num(c.repeatCount, 1));
+      return (num(c.delay, 0) + num(c.duration, 300) * reps) / speed;
+    }
+    default: {
+      const c = cfg(a1).duration !== undefined ? cfg(a1) : cfg(a0);
+      return typeof c.duration === "number" ? num(c.delay, 0) + c.duration : 300;
+    }
+  }
+}
+var KEEP = ["duration", "delay", "stiffness", "damping", "mass", "speed", "repeatCount", "iterationCount"];
+function slimArg(a, idOf) {
+  "worklet";
+  if (typeof a === "number")
+    return a;
+  if (typeof a === "object" && a !== null || typeof a === "function") {
+    const id = idOf(a);
+    if (id !== undefined)
+      return { $anim: id };
+    if (typeof a === "function" || Array.isArray(a))
+      return null;
+    const o = a;
+    const out = {};
+    let any = false;
+    for (let i = 0;i < KEEP.length; i++) {
+      const k = KEEP[i];
+      const v = o[k];
+      if (typeof v === "number" || v === "infinite") {
+        out[k] = v;
+        any = true;
+      }
+    }
+    return any ? out : null;
+  }
+  return null;
+}
+
+// src/version.ts
+var SDK_NAME = "@keyframerdev/vitals";
+var SDK_VERSION = "0.1.0";
+
+// src/controller.ts
+var STORAGE_KEYS = {
+  config: "kfv:config",
+  stop: "kfv:stop",
+  day: "kfv:day",
+  checkpoint: "kfv:checkpoint",
+  queue: "kfv:queue"
+};
+var CHECKPOINT_MS = 60000;
+var STOP_MS = 7 * 24 * 3600000;
+var RETRY = { max: 5, bytes: 100 * 1024, ageMs: 7 * 24 * 3600000, delays: [1e4, 60000, 5 * 60000, 30 * 60000] };
+var START_DELAY_MS = 1e4;
+var MAX_EVENTS = 500;
+var UI_EVENT_BASE = 1e9;
+var isRef2 = (v) => !!v && typeof v === "object" && typeof v.$anim === "number";
+function compareVersions(a, b) {
+  const pa = a.split(/[.+-]/).map((x) => Number.parseInt(x, 10));
+  const pb = b.split(/[.+-]/).map((x) => Number.parseInt(x, 10));
+  for (let i = 0;i < 3; i++) {
+    const x = Number.isFinite(pa[i]) ? pa[i] : 0;
+    const y = Number.isFinite(pb[i]) ? pb[i] : 0;
+    if (x !== y)
+      return x < y ? -1 : 1;
+  }
+  return 0;
+}
+var NONCE_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function makeNonce(random) {
+  let s = "";
+  for (let i = 0;i < 16; i++)
+    s += NONCE_CHARS[Math.floor(random() * NONCE_CHARS.length) % NONCE_CHARS.length];
+  return s;
+}
+function localDay(wall) {
+  const d = new Date(wall);
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+async function read(storage, key) {
+  if (!storage)
+    return null;
+  try {
+    const raw = await storage.getItem(key);
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+async function write(storage, key, value) {
+  if (!storage)
+    return;
+  try {
+    if (value === null)
+      await storage.removeItem(key);
+    else
+      await storage.setItem(key, JSON.stringify(value));
+  } catch {}
+}
+
+class VitalsController {
+  env;
+  collector = new Collector;
+  gate = new MotionGate;
+  opts = null;
+  enabled = false;
+  run = 0;
+  config = null;
+  sampled = false;
+  nonce = "";
+  seq = 0;
+  sampleRate = VITALS_DEFAULT_SAMPLE_RATE;
+  foreground = true;
+  backgroundAt = null;
+  dayCount = null;
+  events = new Map;
+  nextEid = 1;
+  uiKnownUntil = -Infinity;
+  checkpointTimer = null;
+  retryTimer = null;
+  retryStep = 0;
+  queued = 0;
+  configTimer = null;
+  meters = null;
+  screen = "app";
+  reduceMotion = false;
+  constructor(env) {
+    this.env = env;
+  }
+  get isSampled() {
+    return this.sampled;
+  }
+  get isEnabled() {
+    return this.enabled;
+  }
+  get session() {
+    return { nonce: this.nonce, seq: this.seq, sampleRate: this.sampleRate };
+  }
+  async start(opts, meters) {
+    if (this.enabled)
+      this.stop(false);
+    this.opts = opts;
+    this.meters = meters;
+    this.enabled = true;
+    const run = ++this.run;
+    const storage = opts.storage;
+    const stopUntil = await read(storage, STORAGE_KEYS.stop);
+    const cached = await read(storage, STORAGE_KEYS.config);
+    if (run !== this.run)
+      return;
+    if (typeof stopUntil === "number" && stopUntil > this.env.wall()) {
+      this.log("stopped on this device by the project until " + new Date(stopUntil).toISOString());
+      this.enabled = false;
+      return;
+    }
+    this.config = cached?.config ?? null;
+    if (!this.allowed()) {
+      this.enabled = false;
+      return;
+    }
+    const checkpoint = await read(storage, STORAGE_KEYS.checkpoint);
+    if (run !== this.run)
+      return;
+    if (checkpoint) {
+      await write(storage, STORAGE_KEYS.checkpoint, null);
+      await this.enqueue(JSON.stringify(checkpoint));
+    }
+    this.queued = (await read(storage, STORAGE_KEYS.queue) ?? []).length;
+    if (run !== this.run)
+      return;
+    this.retryStep = 0;
+    this.scheduleRetry();
+    const fresh = cached && this.env.wall() - cached.at < Math.max(60, cached.config.ttlSec) * 1000;
+    if (!fresh)
+      this.configTimer = this.env.setTimeout(() => void this.fetchConfig(run), START_DELAY_MS);
+    await this.beginSession(run);
+  }
+  async setEnabled(on) {
+    if (!on)
+      return this.stop(true);
+    if (this.enabled || !this.opts || !this.meters)
+      return;
+    await this.start(this.opts, this.meters);
+  }
+  async stop(drop) {
+    this.run++;
+    this.enabled = false;
+    this.endSampling();
+    this.clearTimers();
+    if (drop)
+      this.queued = 0;
+    if (drop && this.opts?.storage) {
+      await write(this.opts.storage, STORAGE_KEYS.checkpoint, null);
+      await write(this.opts.storage, STORAGE_KEYS.queue, null);
+    }
+  }
+  async beginSession(run) {
+    const now = this.env.now();
+    this.nonce = makeNonce(this.env.random);
+    this.seq = 0;
+    this.sampleRate = this.rate();
+    const env = this.opts.environment ?? "production";
+    const devOk = env === "production" || !this.config || this.config.collect.development;
+    let sampled = devOk && this.sampleRate > 0 && this.env.random() < this.sampleRate;
+    if (sampled) {
+      const day = (this.env.day ?? localDay)(this.env.wall());
+      if (!this.dayCount || this.dayCount.day !== day) {
+        const saved = await read(this.opts.storage, STORAGE_KEYS.day);
+        if (run !== this.run)
+          return;
+        this.dayCount = saved && saved.day === day ? saved : { day, n: 0 };
+      }
+      if (this.dayCount.n >= VITALS_MAX_SESSIONS_PER_DAY)
+        sampled = false;
+      else {
+        this.dayCount.n++;
+        await write(this.opts.storage, STORAGE_KEYS.day, this.dayCount);
+        if (run !== this.run)
+          return;
+      }
+    }
+    this.sampled = sampled;
+    if (!sampled)
+      return;
+    this.collector.clear();
+    this.collector.setReduceMotion(this.reduceMotion);
+    this.collector.setScreen(this.screen, now, false);
+    if (this.foreground)
+      this.collector.foreground(true, now);
+    this.gate.reset();
+    this.events.clear();
+    this.meters.install();
+  }
+  endSampling() {
+    if (this.sampled) {
+      this.meters?.stop();
+      this.meters?.uninstall();
+    }
+    this.sampled = false;
+    this.gate.reset();
+    this.collector.clear();
+    this.events.clear();
+    this.uiKnownUntil = -Infinity;
+    if (this.checkpointTimer !== null) {
+      this.env.clearTimeout(this.checkpointTimer);
+      this.checkpointTimer = null;
+    }
+  }
+  appState(active) {
+    if (!this.enabled)
+      return;
+    const now = this.env.now();
+    if (!active && this.foreground) {
+      this.foreground = false;
+      this.backgroundAt = now;
+      if (this.retryTimer !== null) {
+        this.env.clearTimeout(this.retryTimer);
+        this.retryTimer = null;
+      }
+      if (this.sampled) {
+        this.gate.reset();
+        this.meters?.stop();
+        this.collector.foreground(false, now);
+        this.closeWindow("background");
+      }
+    } else if (active && !this.foreground) {
+      this.foreground = true;
+      const away = this.backgroundAt === null ? 0 : now - this.backgroundAt;
+      this.backgroundAt = null;
+      this.scheduleRetry();
+      if (away > VITALS_SESSION_GAP_MS) {
+        this.endSampling();
+        this.beginSession(this.run);
+      } else if (this.sampled)
+        this.collector.foreground(true, now);
+    }
+  }
+  setScreen(name) {
+    this.screen = name;
+    if (this.sampled)
+      this.collector.setScreen(name, this.env.now());
+  }
+  setReduceMotion(on) {
+    this.reduceMotion = on && !!this.config?.collect.reduceMotion;
+    this.collector.setReduceMotion(this.reduceMotion);
+  }
+  eid() {
+    return this.nextEid++;
+  }
+  anim(site, args, eid, thread, t = this.env.now()) {
+    if (!this.sampled || !this.foreground)
+      return;
+    const ev = { site: { fn: site.fn }, args };
+    this.events.set(eid, ev);
+    if (this.events.size > MAX_EVENTS)
+      this.events.delete(this.events.keys().next().value);
+    const ms = estimateMs(ev, (id) => this.events.get(id));
+    for (const a of args)
+      if (isRef2(a))
+        this.collector.consume(a.$anim);
+    this.collector.animStart(site, t, ms, thread, eid);
+    this.motion(t + ms, t);
+  }
+  layout(site, kind, builder, t = this.env.now()) {
+    const read2 = (k) => {
+      try {
+        const v = builder?.[k];
+        return typeof v === "number" && Number.isFinite(v) ? v : undefined;
+      } catch {
+        return;
+      }
+    };
+    this.anim({ ...site, fn: kind }, [{ duration: read2("durationV") ?? 300, delay: read2("delayV") ?? 0 }], this.eid(), "js", t);
+  }
+  scroll(t = this.env.now()) {
+    if (!this.sampled || !this.foreground)
+      return;
+    this.collector.scroll(t);
+    this.motion(t, t);
+  }
+  touch(down, t = this.env.now()) {
+    if (!this.sampled || !this.foreground)
+      return;
+    this.collector.touch(down, t);
+    if (this.gate.touch(down, t))
+      this.opened(t);
+    this.keepUi(t);
+  }
+  motion(end, now) {
+    if (this.gate.note(end, now))
+      this.opened(now);
+    this.keepUi(now);
+    this.checkWindow(now);
+  }
+  opened(now) {
+    this.collector.measure(true, now);
+    this.meters?.start();
+    this.scheduleCheckpoint();
+  }
+  keepUi(now) {
+    const closes = this.gate.closesAt();
+    const want = closes === Infinity ? now + 2000 : closes;
+    if (want > this.uiKnownUntil + 50 && want > now) {
+      this.uiKnownUntil = want;
+      this.meters?.extendUi(want - now);
+    }
+  }
+  jsFrame(t, dt, budget) {
+    if (!this.sampled || !this.foreground)
+      return false;
+    if (dt > 0)
+      this.collector.frame("js", t, dt, budget);
+    if (!this.gate.open(t)) {
+      this.collector.measure(false, Math.min(t, this.gate.until));
+      return false;
+    }
+    this.keepUi(t);
+    this.checkWindow(t);
+    return true;
+  }
+  uiFrames(buf) {
+    if (!this.sampled)
+      return;
+    for (let i = 0;i + 2 < buf.length; i += 3)
+      this.collector.frame("ui", buf[i], buf[i + 1], buf[i + 2]);
+  }
+  checkWindow(now) {
+    if (this.collector.foregroundAt(now) >= VITALS_WINDOW_MS)
+      this.closeWindow("window");
+  }
+  report(ended, now = this.env.now()) {
+    if (!this.opts)
+      return null;
+    const snap = this.collector.snapshot(now);
+    if (!hasData(snap))
+      return null;
+    return encodeReport(snap, this.context(ended));
+  }
+  async closeWindow(ended) {
+    if (!this.sampled)
+      return;
+    const now = this.env.now();
+    const report = this.report(ended, now);
+    this.collector.reset(now);
+    if (this.checkpointTimer !== null) {
+      this.env.clearTimeout(this.checkpointTimer);
+      this.checkpointTimer = null;
+    }
+    const storage = this.opts?.storage;
+    if (!report) {
+      await write(storage, STORAGE_KEYS.checkpoint, null);
+      return;
+    }
+    this.seq++;
+    await write(storage, STORAGE_KEYS.checkpoint, report);
+    await this.send(JSON.stringify(report));
+    await write(storage, STORAGE_KEYS.checkpoint, null);
+  }
+  scheduleCheckpoint() {
+    if (this.checkpointTimer !== null || !this.opts?.storage)
+      return;
+    this.checkpointTimer = this.env.setTimeout(() => {
+      this.checkpointTimer = null;
+      this.checkpoint();
+    }, CHECKPOINT_MS);
+  }
+  async checkpoint() {
+    if (!this.sampled || !this.opts?.storage)
+      return;
+    const report = this.report("unknown");
+    if (report)
+      await write(this.opts.storage, STORAGE_KEYS.checkpoint, report);
+  }
+  context(ended) {
+    const o = this.opts;
+    const d = o.device ?? {};
+    const collect = this.config?.collect;
+    const memoryGb = d.memoryGb ?? (d.memoryBytes ? Math.round(d.memoryBytes / 1024 ** 3 * 10) / 10 : undefined);
+    const device = { os: this.env.platform.os, osMajor: this.env.platform.osMajor };
+    if (d.model && collect?.deviceModel !== false)
+      device.model = String(d.model).slice(0, 64);
+    if (d.tier)
+      device.tier = d.tier;
+    if (memoryGb)
+      device.memoryGb = memoryGb;
+    const app = {
+      ...o.appId ? { id: o.appId } : {},
+      version: o.appVersion.slice(0, 64),
+      ...o.build ? { build: String(o.build).slice(0, 64) } : {},
+      platform: "react-native",
+      framework: "React Native",
+      environment: o.environment ?? "production"
+    };
+    return {
+      app,
+      sdk: { name: SDK_NAME, version: SDK_VERSION },
+      device,
+      display: d.displayHz ? { hz: d.displayHz } : undefined,
+      collectReduceMotion: !!collect?.reduceMotion,
+      session: { nonce: this.nonce, seq: this.seq, sampleRate: this.sampleRate, ended }
+    };
+  }
+  endpoint() {
+    return (this.opts?.endpoint ?? VITALS_ENDPOINT).replace(/\/+$/, "");
+  }
+  async send(body) {
+    const run = this.run;
+    if (await this.sendOnce(body) === "retry" && run === this.run)
+      await this.enqueue(body);
+  }
+  async enqueue(body) {
+    const storage = this.opts?.storage;
+    if (!storage)
+      return;
+    const queue = await read(storage, STORAGE_KEYS.queue) ?? [];
+    queue.push({ body, at: this.env.wall() });
+    const kept = this.trim(queue);
+    await write(storage, STORAGE_KEYS.queue, kept);
+    this.queued = kept.length;
+    this.scheduleRetry();
+  }
+  trim(queue) {
+    const wall = this.env.wall();
+    const out = [];
+    let bytes = 0;
+    for (let i = queue.length - 1;i >= 0 && out.length < RETRY.max; i--) {
+      const q = queue[i];
+      if (wall - q.at > RETRY.ageMs || typeof q.body !== "string")
+        continue;
+      if (bytes + q.body.length > RETRY.bytes)
+        continue;
+      bytes += q.body.length;
+      out.unshift(q);
+    }
+    return out;
+  }
+  scheduleRetry() {
+    if (this.retryTimer !== null || !this.queued || !this.foreground || !this.enabled || !this.opts?.storage)
+      return;
+    if (this.retryStep >= RETRY.delays.length)
+      return;
+    const delay = RETRY.delays[this.retryStep];
+    this.retryTimer = this.env.setTimeout(() => {
+      this.retryTimer = null;
+      this.retryStep++;
+      this.retry();
+    }, delay);
+  }
+  async retry() {
+    const storage = this.opts?.storage;
+    if (!storage || !this.enabled)
+      return;
+    const run = this.run;
+    const queue = this.trim(await read(storage, STORAGE_KEYS.queue) ?? []);
+    await write(storage, STORAGE_KEYS.queue, null);
+    this.queued = 0;
+    if (!queue.length)
+      return;
+    const left = [];
+    for (const q of queue) {
+      if (run !== this.run)
+        return;
+      const r = await this.sendOnce(q.body);
+      if (r === "retry")
+        left.push(q);
+    }
+    if (left.length && run === this.run) {
+      const now = await read(storage, STORAGE_KEYS.queue) ?? [];
+      const kept = this.trim([...left, ...now]);
+      await write(storage, STORAGE_KEYS.queue, kept);
+      this.queued = kept.length;
+      this.scheduleRetry();
+    }
+  }
+  async sendOnce(body) {
+    try {
+      const res = await this.env.fetch(`${this.endpoint()}/v1/reports`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${this.opts.key}`, "Content-Type": "application/json" },
+        body
+      });
+      if (res.status === 200) {
+        const json = await res.json().catch(() => null);
+        if (json?.config)
+          await this.applyConfig(json.config);
+        return "done";
+      }
+      if (res.status === 401 || res.status === 410) {
+        await this.killSwitch();
+        return "done";
+      }
+      if (res.status === 429 || res.status >= 500)
+        return "retry";
+      this.log(`report refused (${res.status})`);
+      return "done";
+    } catch {
+      return "retry";
+    }
+  }
+  async fetchConfig(run) {
+    this.configTimer = null;
+    if (run !== this.run || !this.opts)
+      return;
+    try {
+      const res = await this.env.fetch(`${this.endpoint()}/v1/config/${encodeURIComponent(this.opts.key)}`, { method: "GET", headers: {} });
+      if (run !== this.run)
+        return;
+      if (res.status === 200) {
+        const config = await res.json();
+        if (config && typeof config === "object" && typeof config.sampleRate === "number")
+          await this.applyConfig(config);
+      } else if (res.status === 401 || res.status === 410)
+        await this.killSwitch();
+    } catch {}
+  }
+  async applyConfig(config) {
+    this.config = config;
+    await write(this.opts?.storage, STORAGE_KEYS.config, { config, at: this.env.wall() });
+    if (config.stop)
+      return this.killSwitch();
+    if (!this.allowed()) {
+      await this.stop(false);
+      return;
+    }
+    if (!config.collect.reduceMotion)
+      this.setReduceMotion(false);
+  }
+  async killSwitch() {
+    this.log("turned off on this device for 7 days by the project");
+    const storage = this.opts?.storage;
+    await this.stop(true);
+    await write(storage, STORAGE_KEYS.stop, this.env.wall() + STOP_MS);
+  }
+  allowed() {
+    const c = this.config;
+    if (!c)
+      return true;
+    if (!c.enabled)
+      return false;
+    const min = c.minSdk?.["react-native"];
+    if (min && compareVersions(SDK_VERSION, min) < 0) {
+      this.log(`this SDK version (${SDK_VERSION}) is below the project's minimum (${min}): off`);
+      return false;
+    }
+    return true;
+  }
+  rate() {
+    const r = this.config ? this.config.sampleRate : this.opts?.sampleRate ?? VITALS_DEFAULT_SAMPLE_RATE;
+    return Number.isFinite(r) ? Math.max(0, Math.min(1, r)) : VITALS_DEFAULT_SAMPLE_RATE;
+  }
+  clearTimers() {
+    for (const k of ["checkpointTimer", "retryTimer", "configTimer"]) {
+      if (this[k] !== null) {
+        this.env.clearTimeout(this[k]);
+        this[k] = null;
+      }
+    }
+  }
+  log(message) {
+    this.env.log?.(`[keyframer vitals] ${message}`);
+  }
+}
+
+// src/hook.ts
+function createJsHook(controller, onMotion) {
+  const ids = new WeakMap;
+  const isObj = (r) => typeof r === "object" && r !== null || typeof r === "function";
+  return {
+    anim(fn, site, args, via, viaSite) {
+      const r = via ? via(fn, viaSite, ...args) : fn(...args);
+      try {
+        const eid = controller.eid();
+        const slim = args.map((a) => slimArg(a, (x) => ids.get(x)));
+        if (isObj(r))
+          ids.set(r, eid);
+        controller.anim(site, slim, eid, "js");
+        onMotion?.();
+      } catch {}
+      return r;
+    },
+    scroll() {
+      controller.scroll();
+    },
+    layout(site, kind, builder) {
+      controller.layout(site, kind, builder);
+    }
+  };
+}
+
+// src/frameMeter.ts
+function createFrameMeter(thread, windowMs = 250) {
+  "worklet";
+  return { thread, windowMs, interval: 1000 / 60, last: -1, windowStart: -1, frames: 0, dropped: 0, fast: 0, mid: 0, stats: [], drops: [] };
+}
+function tickFrameMeter(m, t) {
+  "worklet";
+  const last = m.last;
+  m.last = t;
+  if (last < 0) {
+    m.windowStart = t;
+    return;
+  }
+  const dt = t - last;
+  if (dt <= 0)
+    return;
+  if (dt < 10.5)
+    m.fast += 1;
+  else if (dt < 13)
+    m.mid += 1;
+  const lost = Math.max(0, Math.round(dt / m.interval) - 1);
+  if (lost > 0) {
+    m.dropped += lost;
+    m.drops.push({ t, thread: m.thread, ms: Math.round(dt * 10) / 10, dropped: lost });
+  }
+  m.frames += 1;
+  const span = t - m.windowStart;
+  if (span >= m.windowMs) {
+    m.stats.push({ t, thread: m.thread, fps: Math.round(m.frames * 1000 / span), dropped: m.dropped });
+    const n = m.frames;
+    m.interval = m.fast * 2 > n ? 1000 / 120 : (m.fast + m.mid) * 2 > n ? 1000 / 90 : 1000 / 60;
+    m.frames = 0;
+    m.dropped = 0;
+    m.fast = 0;
+    m.mid = 0;
+    m.windowStart = t;
+  }
+}
+function createFieldMeter(thread) {
+  "worklet";
+  return { m: createFrameMeter(thread), buf: [] };
+}
+function tickFieldMeter(f, t) {
+  "worklet";
+  const last = f.m.last;
+  const interval = f.m.interval;
+  tickFrameMeter(f.m, t);
+  f.m.stats.length = 0;
+  f.m.drops.length = 0;
+  if (last >= 0 && t > last)
+    f.buf.push(t, t - last, interval);
+  return f.buf.length >= 90;
+}
+
+// src/native.ts
+var perf = globalThis.performance;
+var now = () => perf && typeof perf.now === "function" ? perf.now() : Date.now();
+function osMajor() {
+  const v = Platform.Version;
+  if (Platform.OS === "android") {
+    const api = typeof v === "number" ? v : Number.parseInt(String(v), 10);
+    if (!Number.isFinite(api))
+      return 0;
+    if (api >= 29)
+      return api - 20;
+    return { 28: 9, 27: 8, 26: 8, 25: 7, 24: 7, 23: 6 }[api] ?? 0;
+  }
+  const major = Number.parseInt(String(v), 10);
+  return Number.isFinite(major) ? major : 0;
+}
+var env = {
+  now,
+  wall: () => Date.now(),
+  random: Math.random,
+  fetch: (url, init) => fetch(url, init),
+  setTimeout: (fn, ms) => setTimeout(fn, ms),
+  clearTimeout: (h) => clearTimeout(h),
+  platform: { os: Platform.OS === "ios" ? "ios" : "android", osMajor: osMajor() },
+  log: (m) => console.warn(m)
+};
+var controller = new VitalsController(env);
+var jsHook = createJsHook(controller, () => checkScreen());
+var uiOffset = Infinity;
+function onUiFrames(buf, lastTs) {
+  const off = now() - lastTs;
+  if (off < uiOffset)
+    uiOffset = off;
+  for (let i = 0;i < buf.length; i += 3)
+    buf[i] = buf[i] + uiOffset;
+  controller.uiFrames(buf);
+}
+function uiTime(ts) {
+  return ts >= 0 && Number.isFinite(uiOffset) ? ts + uiOffset : now();
+}
+function onUiAnim(site, slim, eid, ts) {
+  controller.anim(site, slim, eid, "ui", uiTime(ts));
+  checkScreen();
+}
+function onUiScroll(ts) {
+  controller.scroll(uiTime(ts));
+}
+function uiKeepAlive(ms) {
+  "worklet";
+  const g = globalThis;
+  const running = g.__kfvLoop;
+  if (running) {
+    if (running.lastTs >= 0)
+      running.until = Math.max(running.until, running.lastTs + ms);
+    else
+      running.pending = Math.max(running.pending, ms);
+    return;
+  }
+  const raf = g.requestAnimationFrame;
+  if (!raf)
+    return;
+  const loop = { f: createFieldMeter("ui"), until: -1, pending: ms, lastTs: -1 };
+  if (g.__kfvInterval)
+    loop.f.m.interval = g.__kfvInterval;
+  g.__kfvLoop = loop;
+  function frame(ts) {
+    const gg = globalThis;
+    if (gg.__kfvLoop !== loop)
+      return;
+    if (loop.pending > 0) {
+      loop.until = Math.max(loop.until, ts + loop.pending);
+      loop.pending = 0;
+    }
+    loop.lastTs = ts;
+    const full = tickFieldMeter(loop.f, ts);
+    gg.__kfvInterval = loop.f.m.interval;
+    if (ts > loop.until) {
+      gg.__kfvLoop = null;
+      scheduleOnRN(onUiFrames, loop.f.buf.splice(0), ts);
+      return;
+    }
+    if (full)
+      scheduleOnRN(onUiFrames, loop.f.buf.splice(0), ts);
+    raf(frame);
+  }
+  raf(frame);
+}
+function installUi(on, base) {
+  scheduleOnUI((enable, first) => {
+    "worklet";
+    const g = globalThis;
+    if (!enable) {
+      g.__KF_VITALS__ = null;
+      g.__kfvLoop = null;
+      return;
+    }
+    const ids = new WeakMap;
+    let next = first;
+    let lastScroll = -1e9;
+    g.__KF_VITALS__ = {
+      anim(fn, site, args, via, viaSite) {
+        const r = via ? via(fn, viaSite, ...args) : fn(...args);
+        try {
+          const eid = next++;
+          const slim = [];
+          for (let i = 0;i < args.length; i++)
+            slim.push(slimArg(args[i], (x) => ids.get(x)));
+          if (typeof r === "object" && r !== null || typeof r === "function")
+            ids.set(r, eid);
+          uiKeepAlive(500);
+          const loop = globalThis.__kfvLoop;
+          scheduleOnRN(onUiAnim, site, slim, eid, loop && loop.lastTs >= 0 ? loop.lastTs : -1);
+        } catch {}
+        return r;
+      },
+      scroll() {
+        uiKeepAlive(500);
+        const loop = globalThis.__kfvLoop;
+        const t = loop && loop.lastTs >= 0 ? loop.lastTs : -1;
+        if (t < 0 || t - lastScroll > 100) {
+          lastScroll = t;
+          scheduleOnRN(onUiScroll, t);
+        }
+      }
+    };
+  }, on, base);
+}
+function stopUi() {
+  scheduleOnUI(() => {
+    "worklet";
+    globalThis.__kfvLoop = null;
+  });
+}
+function extendUi(ms) {
+  scheduleOnUI((m) => {
+    "worklet";
+    uiKeepAlive(m);
+  }, ms);
+}
+var jsMeter = createFieldMeter("js");
+var jsRunning = false;
+function jsTick() {
+  if (!jsRunning)
+    return;
+  const t = now();
+  const last = jsMeter.m.last;
+  const interval = jsMeter.m.interval;
+  tickFrameMeter(jsMeter.m, t);
+  jsMeter.m.stats.length = 0;
+  jsMeter.m.drops.length = 0;
+  if (controller.jsFrame(t, last >= 0 ? t - last : 0, interval))
+    requestAnimationFrame(jsTick);
+  else
+    jsRunning = false;
+}
+var uiInstalled = false;
+var meters = {
+  install() {
+    globalThis.__KF_VITALS__ = jsHook;
+    try {
+      installUi(true, UI_EVENT_BASE);
+      uiInstalled = true;
+    } catch {
+      uiInstalled = false;
+    }
+  },
+  uninstall() {
+    globalThis.__KF_VITALS__ = null;
+    if (uiInstalled)
+      installUi(false, 0);
+    uiInstalled = false;
+  },
+  start() {
+    if (!jsRunning) {
+      jsRunning = true;
+      jsMeter.m.last = -1;
+      requestAnimationFrame(jsTick);
+    }
+  },
+  extendUi(ms) {
+    if (uiInstalled)
+      extendUi(ms);
+  },
+  stop() {
+    jsRunning = false;
+    if (uiInstalled)
+      stopUi();
+  }
+};
+var options = null;
+var subscriptions = [];
+var manualScreen = false;
+function routeName() {
+  const ref = options?.navigationRef;
+  if (!ref)
+    return null;
+  try {
+    if (ref.isReady && !ref.isReady())
+      return null;
+    const route = ref.getCurrentRoute();
+    if (!route?.name)
+      return null;
+    return options?.screenName ? options.screenName(route) : route.name;
+  } catch {
+    return null;
+  }
+}
+var lastRoute = null;
+function checkScreen() {
+  if (manualScreen)
+    return;
+  const name = routeName();
+  if (name === null || name === lastRoute)
+    return;
+  lastRoute = name;
+  controller.setScreen(screenName(name));
+}
+function unsubscribeAll() {
+  for (const off of subscriptions) {
+    try {
+      off();
+    } catch {}
+  }
+  subscriptions = [];
+}
+async function startVitals(opts) {
+  unsubscribeAll();
+  options = opts;
+  lastRoute = null;
+  manualScreen = false;
+  const environment = opts.environment ?? (typeof __DEV__ !== "undefined" && __DEV__ ? "development" : "production");
+  const appState = AppState.addEventListener("change", (s) => controller.appState(s !== "background"));
+  subscriptions.push(() => appState.remove());
+  if (opts.navigationRef) {
+    const off = opts.navigationRef.addListener("state", checkScreen);
+    subscriptions.push(() => typeof off === "function" ? off() : off && typeof off === "object" ? off.remove() : undefined);
+  }
+  try {
+    const rm = AccessibilityInfo.addEventListener("reduceMotionChanged", (on) => controller.setReduceMotion(on));
+    subscriptions.push(() => rm.remove());
+    AccessibilityInfo.isReduceMotionEnabled().then((on) => controller.setReduceMotion(on), () => {
+      return;
+    });
+  } catch {}
+  checkScreen();
+  await controller.start({ ...opts, environment }, meters);
+  checkScreen();
+}
+async function setVitalsEnabled(enabled) {
+  if (!enabled) {
+    unsubscribeAll();
+    touchDown = false;
+    await controller.setEnabled(false);
+  } else if (options && !controller.isEnabled)
+    await startVitals(options);
+}
+function setVitalsScreen(name) {
+  manualScreen = true;
+  controller.setScreen(screenName(name));
+}
+var touchDown = false;
+function vitalsTouch(down, activeTouches) {
+  if (down && !touchDown) {
+    touchDown = true;
+    controller.touch(true);
+  } else if (!down && touchDown && activeTouches === 0) {
+    touchDown = false;
+    controller.touch(false);
+  }
+}
+
+// src/index.ts
+var touches = (e) => e.nativeEvent?.touches?.length ?? 0;
+function VitalsRoot({ children, style }) {
+  return createElement(View, {
+    style: style ?? { flex: 1 },
+    onTouchStart: () => vitalsTouch(true, 1),
+    onTouchEnd: (e) => vitalsTouch(false, touches(e)),
+    onTouchCancel: (e) => vitalsTouch(false, touches(e))
+  }, children);
+}
+export {
+  startVitals,
+  setVitalsScreen,
+  setVitalsEnabled,
+  VitalsRoot,
+  SDK_VERSION
+};