@goliapkg/sentori-react-native 4.0.0 → 5.1.0

package/src/__tests__/transport.test.ts

@@ -1,247 +1,100 @@
-import {
-  describe,
-  it,
-  expect,
-  beforeEach,
-  afterEach,
-  mock,
-} from 'bun:test';
+// Transport on the v1 wire: batch envelope, assert piggyback,
+// offline persistence hooks.
 
-import { clearSpans, startSpan } from '@goliapkg/sentori-core';
+import { afterEach, beforeEach, describe, expect, it, mock } from 'bun:test';
 
-import { setConfig, __resetForTests as resetConfig } from '../config';
+import { __resetForTests as resetConfig, setConfig } from '../config';
 import {
+  __peekAssertStats,
+  __peekQueue,
+  __resetForTests as resetTransport,
+  countAssert,
   enqueue,
   flush,
-  flushSpans,
   startTransport,
-  __resetForTests as resetTransport,
-  __peekQueue,
 } from '../transport';
-import type { Event } from '../types';
 
-const makeEvent = (id: string): Event => ({
-  id,
-  timestamp: '2026-05-09T00:00:00.000Z',
-  kind: 'error',
-  platform: 'javascript',
-  release: 'app@1.0.0+1',
+const baseConfig = {
+  token: 'st_test',
+  ingestUrl: 'http://localhost:18080',
+  release: 'app@1.0.0',
   environment: 'test',
-  device: { os: 'ios', osVersion: '17.0' },
-  app: { version: '1.0.0' },
-  error: {
-    type: 'TypeError',
-    message: 'x',
-    stack: [{ file: 'a.ts', line: 1, inApp: true }],
-    cause: null,
-  },
+  enabled: true,
+  detect: { rageTap: true, longFreeze: true, slowColdStart: true, slowApi: false },
+  replaySeconds: 30,
+};
+
+const wire = (kind: 'error' | 'trace') => ({
+  id: '019e0000-0000-7000-8000-000000000001',
+  kind,
+  occurredAt: new Date().toISOString(),
+  platform: 'javascript' as const,
+  payload: {},
 });
 
 const originalFetch = globalThis.fetch;
 
-describe('transport', () => {
+describe('transport (v1 wire)', () => {
   beforeEach(() => {
-    resetConfig();
     resetTransport();
-    setConfig({
-      token: 'st_pk_test',
-      release: 'app@1.0.0+1',
-      environment: 'test',
-      ingestUrl: 'http://localhost:8080',
-      enabled: true,
-    });
+    resetConfig();
+    setConfig(baseConfig);
     startTransport();
   });
-
   afterEach(() => {
     globalThis.fetch = originalFetch;
+    resetTransport();
+    resetConfig();
   });
 
-  it('enqueues without immediate flush below batch size', () => {
-    enqueue(makeEvent('a'));
-    expect(__peekQueue()).toHaveLength(1);
-  });
-
-  it('flush sends to /v1/events for single event', async () => {
-    const calls: { url: string; init?: RequestInit }[] = [];
-    globalThis.fetch = mock(
-      async (url: string | URL | Request, init?: RequestInit) => {
-        calls.push({ url: String(url), init });
-        return new Response(null, { status: 202 });
-      },
-    ) as typeof fetch;
-
-    enqueue(makeEvent('a'));
-    await flush();
-
-    expect(calls).toHaveLength(1);
-    expect(calls[0]?.url).toBe('http://localhost:8080/v1/events');
-  });
-
-  it('flush sends to /v1/events:batch for multiple events', async () => {
-    const calls: { url: string; init?: RequestInit }[] = [];
-    globalThis.fetch = mock(
-      async (url: string | URL | Request, init?: RequestInit) => {
-        calls.push({ url: String(url), init });
-        return new Response(null, { status: 202 });
-      },
-    ) as typeof fetch;
-
-    enqueue(makeEvent('a'));
-    enqueue(makeEvent('b'));
-    await flush();
-
-    expect(calls).toHaveLength(1);
-    expect(calls[0]?.url).toBe('http://localhost:8080/v1/events:batch');
-    const body = JSON.parse((calls[0]?.init?.body as string) ?? '{}');
-    expect(body.events).toHaveLength(2);
-  });
-
-  it('attaches Authorization and Sentori-Sdk headers', async () => {
-    let capturedHeaders: Record<string, string> | undefined;
-    globalThis.fetch = mock(
-      async (_url: string | URL | Request, init?: RequestInit) => {
-        capturedHeaders = init?.headers as Record<string, string>;
-        return new Response(null, { status: 202 });
-      },
-    ) as typeof fetch;
-
-    enqueue(makeEvent('a'));
-    await flush();
-
-    expect(capturedHeaders?.Authorization).toBe('Bearer st_pk_test');
-    expect(capturedHeaders?.['Sentori-Sdk']).toMatch(/^react-native\//);
-  });
-
-  // Phase 33 sub-D: offline / retry behavior.
-
-  it('retries up to MAX_RETRY (3) on a 5xx, then gives up', async () => {
-    let attempts = 0;
-    globalThis.fetch = mock(async () => {
-      attempts++;
-      return new Response('boom', { status: 503 });
-    }) as typeof fetch;
-
-    enqueue(makeEvent('a'));
-    // flush swallows the final throw (and falls through to persist).
-    // We're verifying the retry count, not the throw.
-    await flush();
-    expect(attempts).toBe(3);
-  });
-
-  it('retries on network error (fetch throw), succeeds when recovered', async () => {
-    let attempts = 0;
-    globalThis.fetch = mock(async () => {
-      attempts++;
-      if (attempts < 3) throw new TypeError('NetworkError: offline');
-      return new Response(null, { status: 202 });
-    }) as typeof fetch;
-
-    enqueue(makeEvent('a'));
-    await flush();
-    expect(attempts).toBe(3);
-  });
-
-  it('drops 4xx-other-than-429 without retry (client errors are unrecoverable)', async () => {
-    let attempts = 0;
-    globalThis.fetch = mock(async () => {
-      attempts++;
-      return new Response(null, { status: 400 });
+  it('posts the batch envelope to /v1/events:batch', async () => {
+    let seenUrl = '';
+    let seenBody: unknown;
+    globalThis.fetch = mock(async (url: unknown, init?: RequestInit) => {
+      seenUrl = String(url);
+      seenBody = JSON.parse(String(init?.body));
+      return new Response(JSON.stringify({ accepted: 1, outcomes: [] }), { status: 200 });
     }) as typeof fetch;
 
-    enqueue(makeEvent('a'));
+    enqueue(wire('error'));
     await flush();
-    // sendOnce treats 4xx-other-than-429 as a no-throw exit, so the
-    // retry loop also exits — one attempt, no double-send.
-    expect(attempts).toBe(1);
+    expect(seenUrl).toBe('http://localhost:18080/v1/events:batch');
+    expect((seenBody as { events: unknown[] }).events.length).toBe(1);
   });
 
-  it('does not duplicate events when flush is called twice in a row', async () => {
-    let attempts = 0;
-    globalThis.fetch = mock(async () => {
-      attempts++;
-      return new Response(null, { status: 202 });
+  it('piggybacks assert stats on the envelope and clears them', async () => {
+    let seenBody: { assertStats?: unknown[] } = {};
+    globalThis.fetch = mock(async (_url: unknown, init?: RequestInit) => {
+      seenBody = JSON.parse(String(init?.body));
+      return new Response(JSON.stringify({ accepted: 0, outcomes: [] }), { status: 200 });
     }) as typeof fetch;
 
-    enqueue(makeEvent('a'));
-    enqueue(makeEvent('b'));
+    countAssert('total-positive', true, 'app@1.0.0');
+    countAssert('total-positive', true, 'app@1.0.0');
+    countAssert('total-positive', false, 'app@1.0.0');
+    expect(__peekAssertStats().length).toBe(1);
     await flush();
-    await flush(); // second flush sees an empty queue and no-ops
-    expect(attempts).toBe(1);
-    expect(__peekQueue()).toHaveLength(0);
-  });
-});
-
-describe('span flush', () => {
-  beforeEach(() => {
-    resetConfig();
+    const stats = seenBody.assertStats as Array<{
+      name: string;
+      passDelta: number;
+      failDelta: number;
+    }>;
+    expect(stats.length).toBe(1);
+    expect(stats[0]?.passDelta).toBe(2);
+    expect(stats[0]?.failDelta).toBe(1);
+    expect(__peekAssertStats().length).toBe(0);
+  });
+
+  it('never flushes before startTransport', async () => {
     resetTransport();
-    clearSpans();
-    setConfig({
-      token: 'st_pk_test',
-      release: 'app@1.0.0+1',
-      environment: 'test',
-      ingestUrl: 'http://localhost:8080',
-      enabled: true,
-    });
-    startTransport();
-  });
-  afterEach(() => {
-    globalThis.fetch = originalFetch;
-    clearSpans();
-  });
-
-  it('POSTs buffered spans to /v1/spans:batch', async () => {
-    const calls: { url: string; init?: RequestInit }[] = [];
-    globalThis.fetch = mock(async (url: string | URL | Request, init?: RequestInit) => {
-      calls.push({ url: String(url), init });
-      return new Response(null, { status: 202 });
-    }) as typeof fetch;
-
-    startSpan('http.client', { name: 'GET /a' }).finish({ status: 'ok' });
-    startSpan('http.client', { name: 'GET /b' }).finish({ status: 'error' });
-    await flushSpans();
-
-    expect(calls).toHaveLength(1);
-    expect(calls[0]?.url).toBe('http://localhost:8080/v1/spans:batch');
-    const body = JSON.parse((calls[0]?.init?.body as string) ?? '{}');
-    expect(body.spans).toHaveLength(2);
-    expect(body.spans[0]).toMatchObject({ op: 'http.client', name: 'GET /a', status: 'ok' });
-  });
-
-  it('no-op when the span buffer is empty', async () => {
-    let attempts = 0;
+    let called = 0;
     globalThis.fetch = mock(async () => {
-      attempts++;
-      return new Response(null, { status: 202 });
-    }) as typeof fetch;
-    await flushSpans();
-    expect(attempts).toBe(0);
-  });
-
-  it('splits >200 spans into multiple batches', async () => {
-    const sizes: number[] = [];
-    globalThis.fetch = mock(async (_url: string | URL | Request, init?: RequestInit) => {
-      const body = JSON.parse((init?.body as string) ?? '{}');
-      sizes.push(body.spans.length);
-      return new Response(null, { status: 202 });
+      called += 1;
+      return new Response('{}', { status: 200 });
     }) as typeof fetch;
-
-    for (let i = 0; i < 450; i++) startSpan('http.client', { name: `GET /${i}` }).finish();
-    await flushSpans();
-
-    expect(sizes).toEqual([200, 200, 50]);
-  });
-
-  it('drops on 5xx without retrying', async () => {
-    let attempts = 0;
-    globalThis.fetch = mock(async () => {
-      attempts++;
-      return new Response('boom', { status: 503 });
-    }) as typeof fetch;
-
-    startSpan('http.client', { name: 'GET /a' }).finish();
-    await flushSpans();
-    expect(attempts).toBe(1);
+    enqueue(wire('trace'));
+    await flush();
+    expect(called).toBe(0);
+    expect(__peekQueue().length).toBe(1);
   });
 });

package/src/__tests__/verbs.test.ts

@@ -0,0 +1,91 @@
+// The five verbs: synchronous, never throw, id out, correct wire.
+
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+
+import { clearSignals } from '@goliapkg/sentori-core';
+
+import { __resetForTests as resetConfig, setConfig } from '../config';
+import { __resetForTests as resetScope } from '../scope';
+import {
+  __peekAssertStats,
+  __peekQueue,
+  __resetForTests as resetTransport,
+  startTransport,
+} from '../transport';
+import { verbs } from '../verbs';
+
+const baseConfig = {
+  token: 'st_test',
+  ingestUrl: 'http://localhost:18080',
+  release: 'app@1.0.0',
+  environment: 'test',
+  enabled: true,
+  detect: { rageTap: true, longFreeze: true, slowColdStart: true, slowApi: false },
+  replaySeconds: 30,
+};
+
+describe('the five verbs', () => {
+  beforeEach(() => {
+    resetTransport();
+    resetConfig();
+    resetScope();
+    clearSignals();
+    setConfig(baseConfig);
+    startTransport();
+  });
+  afterEach(() => {
+    resetTransport();
+    resetConfig();
+    resetScope();
+    clearSignals();
+  });
+
+  it('error coerces anything and enqueues with a stack', () => {
+    const id = verbs.error(new Error('boom'));
+    expect(typeof id).toBe('string');
+    const q = __peekQueue();
+    expect(q.length).toBe(1);
+    expect(q[0]?.kind).toBe('error');
+    expect(q[0]?.payload.error?.type).toBe('Error');
+    expect(q[0]?.payload.error?.message).toBe('boom');
+  });
+
+  it('error serializes Error instances found in data (error-in-data)', () => {
+    verbs.warn('pay.retry', { attempt: 2, error: new TypeError('nope') });
+    const q = __peekQueue();
+    const data = q[0]?.payload.data as { error?: { type?: string } };
+    expect(data.error?.type).toBe('TypeError');
+  });
+
+  it('warn carries name; trace quiet stays out of the queue', () => {
+    verbs.warn('rage_tap');
+    expect(__peekQueue().length).toBe(1);
+    verbs.trace('checkout.start', undefined, { quiet: true });
+    expect(__peekQueue().length).toBe(1); // unchanged
+    verbs.trace('checkout.start');
+    expect(__peekQueue().length).toBe(2);
+  });
+
+  it('assert pass aggregates without an event; fail is an event', () => {
+    verbs.assert('total-positive', true);
+    expect(__peekQueue().length).toBe(0);
+    expect(__peekAssertStats()[0]?.passDelta).toBe(1);
+    verbs.assert('total-positive', false);
+    expect(__peekQueue().length).toBe(1);
+    expect(__peekQueue()[0]?.kind).toBe('assert');
+  });
+
+  it('probe never throws and reports the ref as name', () => {
+    const id = verbs.probe('SENT-123');
+    expect(typeof id).toBe('string');
+    expect(__peekQueue()[0]?.kind).toBe('probe');
+    expect(__peekQueue()[0]?.name).toBe('SENT-123');
+  });
+
+  it('before init everything is a silent no-op that still returns an id', () => {
+    resetConfig();
+    const id = verbs.error(new Error('x'));
+    expect(typeof id).toBe('string');
+    expect(__peekQueue().length).toBe(0);
+  });
+});

package/src/config.ts

@@ -1,58 +1,31 @@
-import type { BeforeSendHook, LogLevel, ReadyInfo } from '@goliapkg/sentori-core';
+// SDK-internal runtime config, set once by init(). Everything else
+// reads through getConfig() and treats null as "not initialized →
+// every verb is a no-op" (the failure-isolation iron rule).
 
-/**
- * v2.3 — `ReadyInfo` is shared across SDKs via `@goliapkg/sentori-core`
- * so a host that switches from web to RN reads the same shape. The RN
- * SDK always populates `native` + `coldStartMs`; the core type marks
- * both optional for the web SDK's benefit (web has no native module).
- */
-export type { ReadyInfo };
+import type { LogLevel, WireEvent } from '@goliapkg/sentori-core';
 
 export type Config = {
   token: string;
+  ingestUrl: string;
   release: string;
   environment: string;
-  ingestUrl: string;
   enabled: boolean;
-  /** Phase 42 sub-D.07: opt-in screenshot capture on captureException. */
-  screenshotsEnabled: boolean;
-  /** Phase 44 sub-B: per-event-class sampling rates 0..1.
-   *  `null` = keep everything (default). */
-  errorSampleRate: null | number;
-  traceSampleRate: null | number;
-  /** v2.0 — sampling rate for `kind: 'message'` events emitted via
-   *  `captureMessage`. `null` = keep all (default). */
-  messageSampleRate: null | number;
-  /** Phase 46: when true, every `captureException` seals the
-   *  session-trail buffer and uploads it as a `sessionTrail`
-   *  attachment. Defaults to false. */
-  sessionTrailEnabled: boolean;
-  /** v2.0 W3 — when true, every `track(name, props)` call also
-   *  pushes a `{ type: 'track', data: { name, props } }` breadcrumb
-   *  so a subsequent capture carries the customer journey. Defaults
-   *  to false to preserve v1 customer breadcrumb shape on upgrade. */
-  trackAutoBreadcrumb: boolean;
-  /** v2.3 — Sentori console output gate.
-   *
-   *  Default `warn`: SDK is silent on host's console unless
-   *  something is genuinely broken (transport sustained failure,
-   *  native module not found, internal SDK exception). No
-   *  per-tick / per-init / per-breadcrumb noise.
-   *
-   *  Set `'silent'` for absolute silence (e.g. CI smoke runs);
-   *  set `'info'` or `'debug'` when debugging Sentori itself. */
+  /** Warn-scenario auto-detection switches (conservative defaults). */
+  detect: {
+    rageTap: boolean;
+    longFreeze: boolean;
+    slowColdStart: boolean;
+    slowApi: boolean;
+  };
+  /** B-type replay rolling buffer, seconds. 0 disables. */
+  replaySeconds: number;
+  replayScreens: boolean;
+  /** Sentori console output gate. Default `warn`: silent on the
+   *  host's console unless something is genuinely broken. */
   logLevel?: LogLevel;
-  /** v2.3 — fires once after init completes. Use this to know the
-   *  SDK is live instead of scanning the console. `info` carries
-   *  the native-module bind status + cold-start timing. Host
-   *  wraps any host-side logging here. */
-  onReady?: (info: ReadyInfo) => void;
-  /** v2.3 — host-side mutate-or-drop hook called once per event
-   *  just before transport enqueue. Return the event to send it,
-   *  `null` to drop. Sync only. If the hook throws or returns a
-   *  non-event, SDK falls back to the un-mutated event and emits
-   *  one one-shot warn. */
-  beforeSend?: BeforeSendHook;
+  /** Host-side mutate-or-drop hook, sync only. Throw / bad return →
+   *  the un-mutated event ships and one warn is emitted. */
+  beforeSend?: (event: WireEvent) => WireEvent | null;
 };
 
 let _config: Config | null = null;

package/src/device.ts

@@ -0,0 +1,36 @@
+// Synchronous device snapshot — what the JS layer can know without
+// crossing the bridge. The native module enriches asynchronously via
+// setNativeDeviceInfo at init; until then the JS-visible subset
+// ships (an event with a thin device beats a delayed event).
+
+import type { Device } from '@goliapkg/sentori-core';
+
+let _native: Partial<Device> | null = null;
+
+export const setNativeDeviceInfo = (info: Partial<Device>): void => {
+  _native = info;
+};
+
+export const collectDevice = (): Device | undefined => {
+  let base: Device | undefined;
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const RN = require('react-native') as {
+      Platform?: { OS?: string; Version?: number | string };
+      Dimensions?: { get(dim: string): { width: number; height: number; scale: number } };
+    };
+    const os = RN.Platform?.OS ?? 'unknown';
+    base = { os, osVersion: RN.Platform?.Version?.toString() };
+    const win = RN.Dimensions?.get('window');
+    if (win) {
+      base.screen = { width: win.width, height: win.height, scale: win.scale };
+    }
+  } catch {
+    return _native ? ({ os: 'unknown', ..._native } as Device) : undefined;
+  }
+  return _native ? { ...base, ..._native } : base;
+};
+
+export const __resetForTests = (): void => {
+  _native = null;
+};

package/src/emit-hooks.ts

@@ -0,0 +1,30 @@
+// Post-emit hooks — how B-type replay (and future reactions) learn
+// "an event just went out" without the verbs knowing about them.
+//
+// Hooks run inside their own try/catch: a broken subscriber must
+// never take the emit path down with it (failure isolation).
+
+import type { WireEvent } from '@goliapkg/sentori-core';
+import { reportInternal } from '@goliapkg/sentori-core';
+
+type EmitHook = (event: WireEvent) => void;
+
+const hooks: EmitHook[] = [];
+
+export const registerEmitHook = (hook: EmitHook): void => {
+  hooks.push(hook);
+};
+
+export const onEventEmitted = (event: WireEvent): void => {
+  for (const hook of hooks) {
+    try {
+      hook(event);
+    } catch (e) {
+      reportInternal('emit-hook', e);
+    }
+  }
+};
+
+export const __resetForTests = (): void => {
+  hooks.length = 0;
+};

package/src/error-boundary.tsx

@@ -1,6 +1,6 @@
 import React, { Component, type ErrorInfo, type ReactNode } from 'react';
 
-import { captureError } from './capture';
+import { error as captureError } from  "./verbs";
 
 export type ErrorBoundaryProps = {
   fallback?: ReactNode | ((error: Error, reset: () => void) => ReactNode);

package/src/handlers/dev-symbolicate.ts

@@ -7,7 +7,7 @@
 // Best-effort and dev-only: any failure (Metro not running, timeout,
 // bad response) leaves the stack untouched. Never throws.
 
-import type { Frame, SentoriError } from '../types';
+import type { Frame, SentoriError } from '@goliapkg/sentori-core';
 
 const TIMEOUT_MS = 2000;
 
@@ -132,6 +132,7 @@ export async function symbolicateErrorViaMetro(
   err: SentoriError,
   opts: { url?: string } = {},
 ): Promise<void> {
+  if (!err.stack) return;
   const sym = await symbolicateStackViaMetro(err.stack, opts);
   if (sym) err.stack = sym;
   if (err.cause) await symbolicateErrorViaMetro(err.cause, opts);

package/src/handlers/global.ts

@@ -1,4 +1,4 @@
-import { captureError } from '../capture';
+import { error as captureError } from '../verbs';
 
 type ErrorUtilsHandler = (error: Error, isFatal?: boolean) => void;
 

package/src/handlers/lifecycle.ts

@@ -12,7 +12,7 @@
  * twice". Sentry historically did the opposite (treat inactive as
  * still alive), but that lets a swiped-away session never end.
  */
-import { endSession, startSession } from '../session-tracker';
+import { pushSignal } from '@goliapkg/sentori-core';
 
 let _installed = false;
 let _subscription: { remove: () => void } | null = null;
@@ -40,9 +40,9 @@ export const installLifecycleHandler = (): void => {
 
   _subscription = AppState.addEventListener('change', (state) => {
     if (state === 'active') {
-      startSession();
+      pushSignal('lifecycle', { state: 'active' });
     } else if (state === 'background' || state === 'inactive') {
-      endSession();
+      pushSignal('lifecycle', { state: 'background' });
     }
   });
 };