@goliapkg/sentori-react-native 4.0.0 → 5.0.0

package/src/long-task-monitor.ts

@@ -1,57 +1,39 @@
-// v0.9.6 #4 — JS thread long-task monitor.
+// long_freeze — detected warn scenario (design.md §3, category B:
+// 「app 卡住了 / 死了几秒」), JS-thread side.
 //
-// What it does: a setInterval(50ms) tick checks how much wall-clock
-// passed vs the requested interval. Excess = the JS thread was busy
-// doing something else for at least that much. When the excess
-// crosses 200ms (a "long task" per Chrome's PerformanceObserver
-// threshold) we emit a `sentori.longtask` span so the dashboard's
-// trace waterfall shows where the JS thread stalled.
+// Mini-spec: a setInterval(50 ms) tick measures wall-clock drift.
+// Drift ≤ 2 s ⇒ a `freeze` signal in the ring (context only —
+// brief jank is not worth an event). Drift > 2 s ⇒ one `warn`
+// event, scenario `long_freeze`, surface = current screen, with the
+// blocked duration. Rate-limited to 6 events/minute so a freeze
+// storm cannot flood ingest.
 //
-// What it does NOT do: capture the stack DURING the long task. JS
-// is single-threaded — by the time our tick runs, the busy code is
-// already gone. The span carries the duration + nearest navigation
-// context (via active span) so triage still has a route to blame.
-//
-// Why this and not a real Hermes sampler: Hermes ships a sampling
-// profiler but accessing it from JS requires RN-internal bridges
-// that vary per RN minor. We could swizzle / vendor headers but
-// that's an Insight-build-config burden. The long-task monitor
-// gets ~80% of the practical value (find slow renders, expensive
-// reducers, accidental sync work in render path) with zero native
-// code + zero RN-version sensitivity.
-//
-// Pairs naturally with +S4 (pre-crash sentinel, RAF frame budget,
-// fires at the slow-frame threshold) — long-task monitor fires
-// further down the slowness scale.
+// What it cannot do: capture the stack DURING the block — JS is
+// single-threaded; by the time our tick runs the busy code is gone.
+// The native watchdogs (HangWatchdog / AnrWatchdog) cover the
+// UI-thread side of the same scenario.
+
+import { pushSignal } from '@goliapkg/sentori-core';
 
-import { startSpan } from '@goliapkg/sentori-core';
+import { currentScreen } from './navigation';
+import { warnDetected } from './verbs';
 
 const TICK_INTERVAL_MS = 50;
-const LONGTASK_THRESHOLD_MS = 200; // > 200ms blocking = a longtask
-const MAX_EMITS_PER_MIN = 60;
+const SIGNAL_THRESHOLD_MS = 200; // ring entry: noticeable jank
+const WARN_THRESHOLD_MS = 2_000; // warn event: a real freeze
+const MAX_WARNS_PER_MIN = 6;
 
 let _timer: ReturnType<typeof setInterval> | null = null;
 let _lastTick = 0;
-let _emitWindowStart = 0;
-let _emitsThisWindow = 0;
+let _warnWindowStart = 0;
+let _warnsThisWindow = 0;
 
-export type LongTaskMonitorOptions = {
-  enabled: boolean;
-  /** Threshold ms above which a tick lag becomes a longtask span.
-   *  Default 200ms. Lower → noisier. */
-  thresholdMs?: number;
-};
-
-export function startLongTaskMonitor(opts: LongTaskMonitorOptions): void {
+export function startLongTaskMonitor(): void {
   if (_timer !== null) return;
-  if (!opts.enabled) return;
-  const threshold = opts.thresholdMs ?? LONGTASK_THRESHOLD_MS;
   _lastTick = Date.now();
-  _emitWindowStart = _lastTick;
-  _emitsThisWindow = 0;
-  _timer = setInterval(() => {
-    tick(threshold);
-  }, TICK_INTERVAL_MS);
+  _warnWindowStart = _lastTick;
+  _warnsThisWindow = 0;
+  _timer = setInterval(tick, TICK_INTERVAL_MS);
   (_timer as unknown as { unref?: () => void }).unref?.();
 }
 
@@ -62,38 +44,34 @@ export function stopLongTaskMonitor(): void {
   }
 }
 
-function tick(threshold: number): void {
+function tick(): void {
   const now = Date.now();
   const elapsed = now - _lastTick;
   _lastTick = now;
   const lag = elapsed - TICK_INTERVAL_MS;
-  if (lag <= threshold) return;
+  if (lag <= SIGNAL_THRESHOLD_MS) return;
+
+  pushSignal('freeze', { blockedMs: Math.round(lag) });
+  if (lag <= WARN_THRESHOLD_MS) return;
 
-  // Rate-limit emits: at most MAX_EMITS_PER_MIN per minute so a
-  // pathological scroll-block-storm doesn't generate 1000 spans.
-  if (now - _emitWindowStart >= 60_000) {
-    _emitWindowStart = now;
-    _emitsThisWindow = 0;
+  if (now - _warnWindowStart >= 60_000) {
+    _warnWindowStart = now;
+    _warnsThisWindow = 0;
   }
-  if (_emitsThisWindow >= MAX_EMITS_PER_MIN) return;
-  _emitsThisWindow += 1;
+  if (_warnsThisWindow >= MAX_WARNS_PER_MIN) return;
+  _warnsThisWindow += 1;
 
-  const span = startSpan('sentori.longtask', {
-    name: 'js.longtask',
-    startNowMs: now - lag,
-    tags: {
-      'profile.kind': 'longtask',
-      'profile.duration_ms': String(Math.round(lag)),
-      'profile.tick_interval_ms': String(TICK_INTERVAL_MS),
-    },
-  });
-  span.finish({ endNowMs: now, status: 'ok' });
+  warnDetected(
+    'long_freeze',
+    { screen: currentScreen() },
+    { blockedMs: Math.round(lag), thread: 'js' },
+  );
 }
 
 /** Test-only. */
 export function __resetLongTaskMonitorForTests(): void {
   stopLongTaskMonitor();
   _lastTick = 0;
-  _emitWindowStart = 0;
-  _emitsThisWindow = 0;
+  _warnWindowStart = 0;
+  _warnsThisWindow = 0;
 }

package/src/mobile-vitals.ts

@@ -1,34 +1,25 @@
-// v0.9.4 #1 — Mobile Vitals.
+// slow_cold_start — detected warn scenario (design.md §3, category
+// C: 「启动过慢」).
 //
-// Three measurements, three call paths, one server schema:
-//
-//   • Cold start: native side measures at app launch (iOS
-//     mach_absolute_time / Android Process.getStartElapsedRealtime)
-//     and exposes via the bundled native module — read once on JS
-//     side at init() and ride along on the first event.
-//   • TTID (Time-To-Initial-Display): automatic via
-//     useTraceNavigation extension — span from navigation.dispatch
-//     to first frame after route mount.
-//   • TTFD (Time-To-Full-Display): manual. Host calls
-//     sentori.markTimeToFullDisplay('Home').end() when the screen's
-//     data has loaded.
-//   • Slow / frozen frame counts: native side hooks CADisplayLink /
-//     Choreographer.FrameCallback; counters flush per navigation
-//     span.
-//
-// JS-side first: TTFD API + bundle-level vital captures. Native
-// pieces ship as a separate native module method `getColdStartMs`
-// + `getFrameCounts()` — graceful no-op if not linked.
+// Mini-spec: the native side measures launch → JS-ready (iOS
+// mach_absolute_time / Android Process.getStartElapsedRealtime);
+// init() calls checkColdStart() once. > 3 s ⇒ one `warn` event,
+// scenario `slow_cold_start`, with the measured ms. Always pushes a
+// `lifecycle` signal so even a fast start shows on the timeline.
+// Graceful no-op when the native module isn't linked (Expo Go,
+// tests).
+
+import { pushSignal } from '@goliapkg/sentori-core';
 
-import { startSpan } from '@goliapkg/sentori-core';
+import { getNativeColdStartMs } from './native';
+import { warnDetected } from './verbs';
 
-import { getNativeColdStartMs, getNativeFrameCounters } from './native';
+const SLOW_COLD_START_MS = 3_000;
 
 let _coldStartMs: null | number = null;
 let _coldStartCaptured = false;
 
-/** Read the native-side cold start measurement once. Cached. Returns
- *  null when the native module isn't linked (Expo Go / tests). */
+/** Read the native-side cold start measurement once. Cached. */
 export function getColdStartMs(): null | number {
   if (_coldStartCaptured) return _coldStartMs;
   _coldStartCaptured = true;
@@ -40,69 +31,18 @@ export function getColdStartMs(): null | number {
   return _coldStartMs;
 }
 
-/**
- * v0.9.4 #1 — Time-To-Full-Display marker. Host calls this at the
- * point the screen is functionally "ready" (data fetched, images
- * loaded, etc.) so the dashboard can show real perceived load time
- * vs auto-detected TTID.
- *
- *     const h = sentori.markTimeToFullDisplay('Home');
- *     // ...data fetched, images rendered...
- *     h.end();
- *
- * If `.end()` is never called, the handle's span is finished as
- * `cancelled` at the next `markTimeToFullDisplay` call (one TTFD in
- * flight at a time is the typical case).
- */
-export type TimeToFullDisplayHandle = {
-  end: (opts?: { status?: 'cancelled' | 'error' | 'ok' }) => void;
-  cancel: () => void;
-};
-
-let _activeTtfd: null | {
-  finish: (status: 'cancelled' | 'error' | 'ok') => void;
-  route: string;
-} = null;
-
-export function markTimeToFullDisplay(route: string): TimeToFullDisplayHandle {
-  if (_activeTtfd && _activeTtfd.route !== route) {
-    _activeTtfd.finish('cancelled');
-  }
-  const span = startSpan('react.navigation.ttfd', {
-    name: route,
-    tags: { 'nav.route': route, 'vital.kind': 'ttfd' },
-  });
-  let finished = false;
-  const finish = (status: 'cancelled' | 'error' | 'ok'): void => {
-    if (finished) return;
-    finished = true;
-    span.finish({ status });
-    if (_activeTtfd && _activeTtfd.route === route) _activeTtfd = null;
-  };
-  _activeTtfd = { finish, route };
-  return {
-    cancel: () => finish('cancelled'),
-    end: (opts?: { status?: 'cancelled' | 'error' | 'ok' }) =>
-      finish(opts?.status ?? 'ok'),
-  };
-}
-
-/** v0.9.4 #1 — read the per-screen slow/frozen frame counts since
- *  the most recent navigation transition. Native module reads
- *  CADisplayLink / Choreographer counters; returns null when not
- *  linked. */
-export function getFrameCounters(): null | { slow: number; frozen: number } {
-  try {
-    return getNativeFrameCounters();
-  } catch {
-    return null;
+/** Called once from init(): signal always, warn when slow. */
+export function checkColdStart(detectEnabled: boolean): void {
+  const ms = getColdStartMs();
+  if (ms === null) return;
+  pushSignal('lifecycle', { phase: 'cold_start', ms });
+  if (detectEnabled && ms > SLOW_COLD_START_MS) {
+    warnDetected('slow_cold_start', {}, { coldStartMs: ms, thresholdMs: SLOW_COLD_START_MS });
   }
 }
 
 /** Test-only. */
 export function __resetMobileVitalsForTests(): void {
-  if (_activeTtfd) _activeTtfd.finish('cancelled');
-  _activeTtfd = null;
   _coldStartCaptured = false;
   _coldStartMs = null;
 }

package/src/native-pending.ts

@@ -0,0 +1,92 @@
+// Native pending-crash drain: the crash handlers (Swift/Kotlin)
+// write one JSON file per crash in the legacy event shape; this
+// module converts them to the v1 wire and enqueues.
+//
+// The converter lives on the JS side so the native writers stay
+// untouched — native code doesn't compile in preflight/CI, and a
+// silent .kt/.swift break ships to npm (the v3.0.0 K2 lesson).
+
+import { uuidV7 } from '@goliapkg/sentori-core';
+import type { SentoriError, WireEvent } from '@goliapkg/sentori-core';
+
+import { drainNativePending } from './native';
+import { enqueue, flush, uploadAttachment } from './transport';
+
+type LegacyNativeEvent = {
+  id?: string;
+  timestamp?: string;
+  platform?: string;
+  release?: string;
+  environment?: string;
+  device?: Record<string, unknown>;
+  app?: Record<string, unknown>;
+  error?: {
+    type?: string;
+    message?: string;
+    stack?: Array<Record<string, unknown>>;
+  };
+  _pendingAttachments?: Array<{
+    kind?: string;
+    base64?: string;
+    mediaType?: string;
+    source?: string;
+  }>;
+};
+
+const toWire = (raw: LegacyNativeEvent): WireEvent => {
+  const platform = raw.platform === 'android' ? 'android' : 'ios';
+  const error: SentoriError = {
+    type: raw.error?.type ?? 'NativeCrash',
+    message: raw.error?.message ?? '',
+    stack: (raw.error?.stack ?? []).map((f) => ({
+      file: typeof f.file === 'string' ? f.file : undefined,
+      function: typeof f.function === 'string' ? f.function : undefined,
+      line: typeof f.line === 'number' ? f.line : undefined,
+      inApp: typeof f.inApp === 'boolean' ? f.inApp : undefined,
+    })),
+    cause: null,
+  };
+  return {
+    id: raw.id ?? uuidV7(),
+    kind: 'error',
+    occurredAt: raw.timestamp ?? new Date().toISOString(),
+    platform,
+    release: raw.release ?? '',
+    environment: raw.environment ?? '',
+    payload: {
+      error,
+      device: raw.device as WireEvent['payload']['device'],
+      app: raw.app as WireEvent['payload']['app'],
+      nativeCrash: true,
+    },
+  };
+};
+
+/** Drain, convert, enqueue, and ship pre-death attachments. */
+export const shipNativePending = async (): Promise<void> => {
+  const files = await drainNativePending();
+  for (const text of files) {
+    try {
+      const raw = JSON.parse(text) as LegacyNativeEvent;
+      const pending = raw._pendingAttachments;
+      delete raw._pendingAttachments;
+      const wire = toWire(raw);
+      enqueue(wire);
+      if (pending && wire.id) {
+        for (const att of pending) {
+          if (att.base64 && att.kind) {
+            void uploadAttachment(
+              wire.id,
+              att.kind as import('@goliapkg/sentori-core').AttachmentKind,
+              { base64: att.base64, mediaType: att.mediaType ?? 'application/octet-stream' },
+              { source: (att.source as 'android' | 'ios' | 'js') ?? 'ios' },
+            );
+          }
+        }
+      }
+    } catch {
+      // One corrupt crash file must not block the rest.
+    }
+  }
+  if (files.length > 0) await flush();
+};

package/src/navigation.ts

@@ -1,35 +1,17 @@
-// Phase 35 sub-C: react-navigation auto-instrumentation.
-// Phase 39 sub-B: the open `react.navigation` span is also made the
-// active span for that screen's lifetime, so the screen's
-// `http.client` spans (and any other startSpan() calls) attach to it
-// as children — one trace per screen instead of one per request.
+// react-navigation auto-instrumentation — v1 role: feed the signal
+// ring (`nav` signals) and remember the current screen so warn
+// surfaces can name where they happened. The span/trace/metric
+// machinery this file used to drive is gone with the APM vocabulary.
 //
 // Mount `useTraceNavigation(navigationRef)` next to your
-// `<NavigationContainer ref={navigationRef}>`. Span names are
-// `<from> → <to>` (or just the route name for the first screen) so
-// the trace list reads as a navigation log.
-//
-// react-navigation is an OPTIONAL peer dependency — apps that don't
-// use it never have to install it. The hook doesn't import from
-// @react-navigation/native; consumers pass in the ref they already
-// have, and we read its state via the public `getCurrentRoute()`.
-//
-// Caveat (active-span on RN is a module variable): requests fired
-// from a `setTimeout` / background poll / detached promise after the
-// screen settled may not see the nav span as active. If you want such
-// a request parented to the current screen, pass it explicitly:
-// `startSpan(op, { parent: activeSpan() })`.
+// `<NavigationContainer ref={navigationRef}>`. react-navigation
+// stays an OPTIONAL peer dependency: the hook never imports from
+// @react-navigation/native — consumers pass the ref they already
+// have and we read `getCurrentRoute()`.
 
 import { useEffect, useRef } from 'react';
 
-import { emitMetric, setActiveSpan, startSpan, type SpanHandle } from '@goliapkg/sentori-core';
-
-import {
-  getNativeFrameCounters,
-  resetNativeFrameCounters,
-} from './native';
-import { track } from './track';
-import { captureStep } from './trail';
+import { pushSignal } from '@goliapkg/sentori-core';
 
 /** Minimal contract: anything with `addListener('state', cb)` and
  *  `getCurrentRoute()` works. The real @react-navigation/native
@@ -39,150 +21,60 @@ export type NavigationRefLike = {
   getCurrentRoute: () => { name: string } | undefined;
 };
 
-/** Process-global last-known route — populated by the navigation
- *  span path below, read by the analytics heartbeat so its per-tick
- *  payload includes the screen the user is on right now. Initial null
- *  when no nav has happened yet (app just launched, dev-launcher,
- *  splash). */
+/** Process-global last-known route — surfaces on detected warns
+ *  (`surface.screen`) and rides nav signals. Null before the first
+ *  navigation (splash, dev launcher). */
 let _lastRoute: null | string = null;
 
+export function currentScreen(): string | undefined {
+  return _lastRoute ?? undefined;
+}
+
+/** Kept for compat with earlier integrations. */
 export function getLastRoute(): null | string {
   return _lastRoute;
 }
 
-/**
- * Subscribe to react-navigation state changes and emit a
- * `react.navigation` span per screen (including the initial one),
- * each a fresh trace root. The span is kept active while the screen
- * is current; child spans created in that window attribute up to it.
- *
- *     import { NavigationContainer, useNavigationContainerRef } from '@react-navigation/native'
- *     import { useTraceNavigation } from '@goliapkg/sentori-react-native'
- *
- *     function App() {
- *       const navigationRef = useNavigationContainerRef()
- *       useTraceNavigation(navigationRef)
- *       return <NavigationContainer ref={navigationRef}>{...}</NavigationContainer>
- *     }
- *
- * Each span carries `{ nav.from, nav.to }` tags.
- */
 export function useTraceNavigation(navigationRef: NavigationRefLike): void {
-  // Latest route name we've observed.
   const lastRouteRef = useRef<null | string>(null);
-  // Wall-clock ms when the last screen was entered. Drives dwell time
-  // attached to the leaving span + the next captureStep breadcrumb.
-  const lastRouteEnteredAtRef = useRef<null | number>(null);
-  // Span for the screen the user is currently on. Finished when the
-  // next screen is entered (or on unmount).
-  const openSpanRef = useRef<null | SpanHandle>(null);
+  const enteredAtRef = useRef<null | number>(null);
 
   useEffect(() => {
     if (typeof navigationRef.addListener !== 'function') return;
     if (typeof navigationRef.getCurrentRoute !== 'function') return;
 
-    // Each screen gets its own trace root — detach from whatever the
-    // previous screen's span was (we keep it active, so without
-    // `parent: null` the new one would nest under it).
-    const openScreenSpan = (
-      from: null | string,
-      to: string,
-      prevDwellMs: null | number,
-    ) => {
-      const span = startSpan('react.navigation', {
-        name: from ? `${from} → ${to}` : to,
-        parent: null,
-        tags: { 'nav.from': from ?? '', 'nav.to': to },
-      });
-      openSpanRef.current = span;
-      setActiveSpan(span);
+    const noteScreen = (from: null | string, to: string) => {
+      const dwellMs =
+        enteredAtRef.current !== null
+          ? Math.max(0, Date.now() - enteredAtRef.current)
+          : undefined;
       lastRouteRef.current = to;
       _lastRoute = to;
-      lastRouteEnteredAtRef.current = Date.now();
-      // v0.8.0-b — dwell on the previous screen surfaces in the
-      // session trail. The leaving span's `durationMs` already
-      // carries the same number, but the trail is the most-glanced
-      // surface so we duplicate it as breadcrumb data. No bytes wasted:
-      // a breadcrumb without sessionTrail enabled is a no-op.
-      captureStep(`screen:${to}`, {
-        breadcrumb: {
-          data: prevDwellMs !== null ? { dwellMsPrev: prevDwellMs } : undefined,
-          message: from ? `${from} → ${to}` : to,
-          type: 'navigation',
-        },
-      });
-      // v1.1 chunk B — auto-pageview. Pushed into the track ring
-      // alongside the navigation span so the analytics path sees
-      // every screen entry without app code needing to wire its own
-      // pageview calls. `from`/`dwellMsPrev` ride in props so the
-      // Behavior view (chunk D) can reconstruct the user journey
-      // even when only the track stream is queried.
-      track(
-        '$pageview',
-        prevDwellMs !== null
-          ? { from: from ?? null, dwellMsPrev: prevDwellMs }
-          : { from: from ?? null },
+      enteredAtRef.current = Date.now();
+      pushSignal('nav', {
+        from: from ?? undefined,
         to,
-      );
-    };
-
-    const finishOpenSpanWithDwell = (): null | number => {
-      const span = openSpanRef.current;
-      const enteredAt = lastRouteEnteredAtRef.current;
-      if (!span) return null;
-      const dwellMs = enteredAt !== null ? Math.max(0, Date.now() - enteredAt) : null;
-      // v0.9.4 #1 — drain native frame counters at screen-leave.
-      // Empty/null when native module not linked; tags omitted.
-      const fc = getNativeFrameCounters();
-      const finishTags: Record<string, string> = {};
-      if (dwellMs !== null) finishTags['nav.dwell_ms'] = String(dwellMs);
-      if (fc) {
-        finishTags['vital.slow_frames'] = String(fc.slow);
-        finishTags['vital.frozen_frames'] = String(fc.frozen);
-      }
-      span.finish({
-        status: 'ok',
-        tags: Object.keys(finishTags).length > 0 ? finishTags : undefined,
+        dwellMsPrev: dwellMs,
       });
-      // Reset counters for the next screen.
-      resetNativeFrameCounters();
-      return dwellMs;
     };
 
-    // Open a span for the initial screen so its requests are grouped
-    // too (auth / config / first data load are usually the busiest
-    // screen of a session).
     const initial = navigationRef.getCurrentRoute()?.name ?? null;
-    if (initial !== null) openScreenSpan(null, initial, null);
-    else lastRouteRef.current = null;
+    if (initial !== null) noteScreen(null, initial);
 
     const unsubscribe = navigationRef.addListener('state', () => {
       const next = navigationRef.getCurrentRoute()?.name ?? null;
       const prev = lastRouteRef.current;
       if (next === null || next === prev) return;
-      const dwellMs = finishOpenSpanWithDwell();
-      // v2.1 W2 — emit dwell as a runtime metric so the BI panel
-      // can rank screens by how long users sat on them. Tagged
-      // with `from` + `to` so a release-over-release diff can spot
-      // a 2x dwell regression on Onboarding etc. emit is cheap +
-      // bounded by the core ring cap; if `capture.runtimeMetrics:
-      // false` the flush is off but the ring still records up to
-      // the cap before dropping oldest.
-      if (typeof dwellMs === 'number' && dwellMs >= 0) {
-        emitMetric('runtime.route_nav_ms', dwellMs, {
-          from: prev ?? '',
-          to: next ?? '',
-        });
-      }
-      openScreenSpan(prev, next, dwellMs);
+      noteScreen(prev, next);
     });
 
     return () => {
       unsubscribe();
-      finishOpenSpanWithDwell();
-      openSpanRef.current = null;
-      lastRouteEnteredAtRef.current = null;
-      setActiveSpan(null);
+      enteredAtRef.current = null;
     };
   }, [navigationRef]);
 }
+
+export const __resetForTests = (): void => {
+  _lastRoute = null;
+};

package/src/netinfo.ts

@@ -5,11 +5,11 @@
 // standard library), we subscribe at SDK init time and cache the
 // latest network state. `collectDevice()` reads the cache
 // synchronously at capture time. If the peer isn't installed, the
-// cache stays `undefined` and `device.networkType` is omitted —
+// cache stays `undefined` and `device.network` is omitted —
 // no warning, no crash.
 //
 // We collapse NetInfo's enum into the smaller set the protocol
-// allows (see `Device.networkType` in `sdk/core/src/types.ts`):
+// allows (see `Device.network` in `sdk/core/src/types.ts`):
 // `wifi`, `2g/3g/4g/slow-2g`, `offline`, `unknown`. 5G collapses
 // into `4g` because the schema doesn't have a 5g slot yet; the
 // information loss is acceptable for an analytics dimension.
@@ -18,7 +18,7 @@ import type { Device } from '@goliapkg/sentori-core';
 
 import { isNativeModuleLinked } from './native-loader';
 
-type NetworkType = Device['networkType'];
+type NetworkType = Device['network'];
 
 type NetInfoState = {
   details?: { cellularGeneration?: null | string };

package/src/push.ts

@@ -21,9 +21,8 @@
 //      buffered events while the app is foreground. Pauses on
 //      background, resumes on active, per the perf iron rule.
 
-import { addBreadcrumb, logger } from '@goliapkg/sentori-core'
+import { logger, pushSignal } from '@goliapkg/sentori-core'
 
-import { track } from './track.js'
 // AppState is RN-only; we treat it dynamically so the SDK keeps
 // importing cleanly under Bun / web.
 type AppStateModule = {
@@ -318,13 +317,11 @@ function autoCorrelate(
   // Breadcrumb buffer: O(1) in-memory push. Tag both event types
   // ('received' vs 'opened') so a later captureException shows
   // whether the user actually saw the push.
-  addBreadcrumb('push', { body, msgId, opened: eventType === 'opened', provider, title })
+  pushSignal('push', { body: undefined, msgId, opened: eventType === 'opened', provider, title })
 
   // Track event: reuses the existing SDK event pipeline. Two
   // distinct names so dashboards can separate delivery from open.
   const trackName = eventType === 'opened' ? 'sentori.push.opened' : 'sentori.push.received'
-  track(trackName, { msgId, provider })
-
   // Enqueue ack — batched, see drainAckQueue.
   enqueueAck(msgId)
 }