@goliapkg/sentori-react-native 3.1.0 → 5.0.0

package/src/rage-tap.tsx

@@ -1,22 +1,24 @@
-// v0.9.0 #12 — rage-tap / multi-click detection.
+// rage_tap — the first detected warn scenario (design.md §3,
+// category A: 「我按了没反应/反复按」).
 //
-// Wrap your app root (typically next to ErrorBoundary) with
-// `<sentori.RageTapCapture>{children}</sentori.RageTapCapture>`.
-// We listen to bubble-phase `onTouchEnd` and emit a `ui.multiClick`
-// breadcrumb when the same native target receives ≥ 3 taps within
-// 800 ms. Pure observation — no event capture, no gesture
-// interference; existing Touchables / Pressables / GestureHandler
-// continue to fire normally.
+// Wrap the app root (next to ErrorBoundary) with
+// `<RageTapCapture>{children}</RageTapCapture>`. Bubble-phase
+// `onTouchEnd` only — pure observation, no gesture interference.
+//
+// Mini-spec: ≥3 taps on the same native target within 800 ms ⇒ one
+// `warn` event, scenario `rage_tap`, surface = current screen +
+// target id, plus a signal-ring entry. Per-target cooldown resets
+// after firing so a frustrated 10-tap burst is one event, not four.
 
 import React, { useCallback, useRef } from 'react';
 import { View, type GestureResponderEvent, type ViewProps } from 'react-native';
 
-import { addBreadcrumb } from './breadcrumbs';
-import {
-  RAGE_THRESHOLD,
-  RAGE_WINDOW_MS,
-  recordTap,
-} from './rage-tap-detector';
+import { pushSignal } from '@goliapkg/sentori-core';
+
+import { getConfig } from './config';
+import { currentScreen } from './navigation';
+import { RAGE_THRESHOLD, RAGE_WINDOW_MS, recordTap } from './rage-tap-detector';
+import { warnDetected } from './verbs';
 
 export function RageTapCapture({
   children,
@@ -25,18 +27,19 @@ export function RageTapCapture({
   const recent = useRef<Map<number, number[]>>(new Map());
 
   const onTouchEnd = useCallback((e: GestureResponderEvent) => {
-    const target = e.nativeEvent?.target;
-    if (typeof target !== 'number') return;
-    if (recordTap(recent.current, target, Date.now())) {
-      addBreadcrumb({
-        type: 'user',
-        data: {
-          kind: 'ui.multiClick',
-          target: String(target),
-          taps: RAGE_THRESHOLD,
-          windowMs: RAGE_WINDOW_MS,
-        },
-      });
+    try {
+      const target = e.nativeEvent?.target;
+      if (typeof target !== 'number') return;
+      pushSignal('tap', { target });
+      if (!recordTap(recent.current, target, Date.now())) return;
+      if (getConfig()?.detect.rageTap === false) return;
+      warnDetected(
+        'rage_tap',
+        { screen: currentScreen(), element: String(target) },
+        { taps: RAGE_THRESHOLD, windowMs: RAGE_WINDOW_MS },
+      );
+    } catch {
+      // A detector bug must never reach the host's touch pipeline.
     }
   }, []);
 

package/src/replay.ts

@@ -15,9 +15,8 @@
 //
 // Wire schema: docs/replay-encoding-v2.md.
 
-import { logger, startSpan } from '@goliapkg/sentori-core';
+import { logger } from '@goliapkg/sentori-core';
 
-import { getRegisteredMaskQuery } from './mask';
 import { describeWireframeNative } from './native';
 
 declare const __DEV__: boolean | undefined;
@@ -153,18 +152,11 @@ function captureTick(): void {
     logger.debug('replay', 'tick: first invocation');
     _firstTickLogged = true;
   }
-  let tickSpan: ReturnType<typeof startSpan> | null = null;
-  try {
-    tickSpan = startSpan('sentori.replay.tick', { name: 'tick' });
-  } catch {
-    // never fatal
-  }
   try {
     const maskIds = readMaskIds();
     const snapshotJson = _nativeMod?.captureWireframe?.(maskIds);
     if (typeof snapshotJson !== 'string' || snapshotJson.length === 0) {
       handleEmptyTick(snapshotJson);
-      tickSpan?.finish({ status: 'ok' });
       return;
     }
 
@@ -173,7 +165,6 @@ function captureTick(): void {
       snapshot = JSON.parse(snapshotJson) as NativeFrame;
     } catch (e) {
       logger.warn('replay', 'tick: native JSON parse failed', e);
-      tickSpan?.finish({ status: 'error' });
       return;
     }
 
@@ -185,10 +176,7 @@ function captureTick(): void {
     if (typeof __DEV__ !== 'undefined' && __DEV__) {
       diagnosticForTick(snapshot, snapshotJson.length);
     }
-    tickSpan?.finish({ status: 'ok' });
   } catch (e) {
-    if (e instanceof Error) tickSpan?.setTag('error.message', e.message);
-    tickSpan?.finish({ status: 'error' });
     logger.warn('replay', 'tick threw', e);
   }
 }
@@ -326,13 +314,8 @@ function diagnosticForTick(snapshot: NativeFrame, snapshotBytes: number): void {
 }
 
 function readMaskIds(): string[] {
-  const q = getRegisteredMaskQuery();
-  if (!q) return [];
-  try {
-    return q();
-  } catch {
-    return [];
-  }
+  // Masking returns with a v1 privacy pass; nothing masks today.
+  return [];
 }
 
 type ReplayNativeModule = {

package/src/scope.ts

@@ -0,0 +1,50 @@
+// Ambient scope: the current user and the context patch, attached
+// to every outgoing event. Two verbs own this state (user() and
+// context()); everything else reads it.
+
+import { hashIdentities, safeFn } from '@goliapkg/sentori-core';
+import type { User } from '@goliapkg/sentori-core';
+
+let _user: User | null = null;
+let _userKey: string | undefined;
+let _context: Record<string, unknown> = {};
+let _hashGeneration = 0;
+
+export const setUser = safeFn('user', function setUser(u: User | null): void {
+  _user = u;
+  _userKey = undefined;
+  const generation = ++_hashGeneration;
+  if (u === null) return;
+  // The wire carries only a salted hash — raw identity never leaves
+  // the device (breadth × depth needs distinctness, not identity).
+  // Hashing is async (WebCrypto); the verb stays synchronous and the
+  // key lands a tick later. Events sent in that gap simply carry no
+  // userKey, which only under-counts breadth briefly.
+  void hashIdentities({ email: u.email, id: u.id })
+    .then((hashes) => {
+      if (generation === _hashGeneration) {
+        _userKey = hashes.id ?? hashes.email;
+      }
+    })
+    .catch(() => {
+      // NEVER rule: no key beats a raw identity on the wire.
+    });
+});
+
+export const patchContext = safeFn('context', function patchContext(
+  patch: Record<string, unknown>,
+): void {
+  _context = { ..._context, ...patch };
+});
+
+export const currentUserKey = (): string | undefined => _userKey;
+
+export const currentContext = (): Record<string, unknown> | undefined =>
+  Object.keys(_context).length > 0 ? { ..._context } : undefined;
+
+export const __resetForTests = (): void => {
+  _user = null;
+  _userKey = undefined;
+  _context = {};
+  _hashGeneration++;
+};