@scalebun/react-native 1.10.7 → 1.11.1

package/src/features/journey/ScaleBunDebugRoot.tsx

@@ -28,9 +28,14 @@ import React, {
     type ReactNode,
 } from 'react';
 import { View, NativeEventEmitter, NativeModules } from 'react-native';
-import { emitAutomaticEvent } from '../../analytics/automaticEvents';
 import { resolveTouchTarget, describeTouchTarget } from './touchTarget';
 import { resolvePlatformOS } from '../../core/context/device';
+import {
+    INTERACTION_PROTOCOL_VERSION,
+    generateInteractionId,
+    nearestInteractionStart,
+    type InteractionStartContext,
+} from './interactionProtocol';
 
 // ─── Lazy imports to avoid native module cascade at load time ────────────────
 // We only import TYPE references at the top level; actual modules are require()'d
@@ -60,6 +65,11 @@ interface ScaleBunDebugRootProps {
     suppressDeprecationWarning?: boolean;
 }
 
+interface TouchStartContext extends InteractionStartContext {
+    locationX?: number;
+    locationY?: number;
+}
+
 export function ScaleBunDebugRoot({
     children,
     navigationRef,
@@ -270,7 +280,9 @@ export function ScaleBunDebugRoot({
     // and forwards them to SessionManager as USER_ACTION events.
     const lastNativeTouchTsRef = useRef<number>(0);
     const nativeTrackingConfirmedRef = useRef<boolean>(false);
-    const pendingJsEmitRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+    const touchStartRef = useRef<TouchStartContext | null>(null);
+    const interactionStartsRef = useRef<TouchStartContext[]>([]);
+    const pendingJsEmitsRef = useRef<Map<string, ReturnType<typeof setTimeout>>>(new Map());
 
     useEffect(() => {
         let subscription: any = null;
@@ -284,10 +296,19 @@ export function ScaleBunDebugRoot({
                     lastNativeTouchTsRef.current = Date.now();
                     nativeTrackingConfirmedRef.current = true;
 
-                    // Cancel any pending JS emission — native event wins
-                    if (pendingJsEmitRef.current !== null) {
-                        clearTimeout(pendingJsEmitRef.current);
-                        pendingJsEmitRef.current = null;
+                    const nativeOccurredAt =
+                        typeof event.occurredAt === 'number'
+                            ? event.occurredAt
+                            : (typeof event.timestamp === 'number' ? event.timestamp : Date.now()) -
+                              (typeof event.durationMs === 'number' ? event.durationMs : 0);
+                    const start = nearestInteractionStart(interactionStartsRef.current, nativeOccurredAt);
+
+                    // Cancel only this physical touch's fallback. A single timer used to cancel a
+                    // previous rapid tap and silently lose it on devices without native tracking.
+                    if (start) {
+                        const pending = pendingJsEmitsRef.current.get(start.interactionId);
+                        if (pending !== undefined) clearTimeout(pending);
+                        pendingJsEmitsRef.current.delete(start.interactionId);
                     }
 
                     const { SessionManager } = require('../session/SessionManager');
@@ -306,6 +327,15 @@ export function ScaleBunDebugRoot({
                     } catch { /* no-throw */ }
 
                     (sm as any).onGestureDetected(event.gestureType || 'tap', {
+                        interactionId: event.interactionId || start?.interactionId || generateInteractionId(),
+                        interactionProtocol: event.interactionProtocol || INTERACTION_PROTOCOL_VERSION,
+                        occurredAt: nativeOccurredAt,
+                        ui: start?.ui,
+                        stateStatus: start?.stateStatus ?? 'not_captured',
+                        target: start?.target,
+                        targetId: start?.targetId,
+                        screenName: start?.screenName,
+                        emitAutomaticAnalytics: start?.emitAutomaticAnalytics ?? captureAutomaticInteractions,
                         x: event.rawX,
                         y: event.rawY,
                         // Use the actual native end coords when present, not the down
@@ -334,11 +364,12 @@ export function ScaleBunDebugRoot({
 
         return () => {
             try { subscription?.remove(); } catch { /* no-throw */ }
+            for (const timer of pendingJsEmitsRef.current.values()) clearTimeout(timer);
+            pendingJsEmitsRef.current.clear();
         };
-    }, []);
+    }, [captureAutomaticInteractions]);
 
     // ─── Touch Tracking State ───────────────────────────────────────────
-    const touchStartRef = useRef<{ x: number; y: number; ts: number } | null>(null);
 
     // On-screen rect of the root view — the EXACT view the native screenshot
     // captures. Normalizing pageX/pageY against this rect makes JS-fallback taps
@@ -377,7 +408,36 @@ export function ScaleBunDebugRoot({
     const handleTouchStart = (e: any) => {
         try {
             const touch = e.nativeEvent;
-            touchStartRef.current = { x: touch.pageX, y: touch.pageY, ts: Date.now() };
+            const target = resolveTouchTarget(e);
+            let ui: string | undefined;
+            let screenName: string | undefined;
+            try {
+                const { uiStateSignature } = require('./uiState');
+                ui = uiStateSignature();
+            } catch { /* no-throw */ }
+            try {
+                const { AutoScreenDetector } = require('../navigation/AutoScreenDetector');
+                screenName = AutoScreenDetector.getInstance().getCurrentScreen() || undefined;
+            } catch { /* no-throw */ }
+            const start: TouchStartContext = {
+                interactionId: generateInteractionId(),
+                occurredAt: Date.now(),
+                x: touch.pageX,
+                y: touch.pageY,
+                locationX: touch.locationX,
+                locationY: touch.locationY,
+                target: describeTouchTarget(target),
+                targetId: target?.testID,
+                screenName,
+                ui,
+                stateStatus: ui ? 'captured_nonempty' : 'not_instrumented',
+                emitAutomaticAnalytics: captureAutomaticInteractions,
+            };
+            touchStartRef.current = start;
+            interactionStartsRef.current = interactionStartsRef.current
+                .filter((candidate) => start.occurredAt - candidate.occurredAt < 5000)
+                .concat(start)
+                .slice(-8);
         } catch { /* no-throw */ }
     };
 
@@ -413,16 +473,24 @@ export function ScaleBunDebugRoot({
             // WHAT was tapped, resolved from the React fiber on the touch event. Without this the tap
             // carries only coordinates, so every tap in the app groups into one row per gesture type.
             // Defensive by construction — returns undefined rather than throwing (see touchTarget.ts).
-            const tapped = describeTouchTarget(resolveTouchTarget(e));
+            const tapped = start?.target ?? describeTouchTarget(resolveTouchTarget(e));
 
             const gestureDetails: any = {
                 target: tapped,
-                x: touch.pageX,
-                y: touch.pageY,
-                pageX: touch.pageX,
-                pageY: touch.pageY,
-                locationX: touch.locationX,
-                locationY: touch.locationY,
+                interactionId: start?.interactionId ?? generateInteractionId(),
+                interactionProtocol: INTERACTION_PROTOCOL_VERSION,
+                occurredAt: start?.occurredAt ?? Date.now(),
+                ui: start?.ui,
+                stateStatus: start?.stateStatus ?? 'not_captured',
+                targetId: start?.targetId,
+                screenName: start?.screenName,
+                emitAutomaticAnalytics: start?.emitAutomaticAnalytics ?? captureAutomaticInteractions,
+                x: start?.x ?? touch.pageX,
+                y: start?.y ?? touch.pageY,
+                pageX: start?.x ?? touch.pageX,
+                pageY: start?.y ?? touch.pageY,
+                locationX: start?.locationX ?? touch.locationX,
+                locationY: start?.locationY ?? touch.locationY,
                 viewportWidth: vpW > 0 ? vpW : undefined,
                 viewportHeight: vpH > 0 ? vpH : undefined,
             };
@@ -434,8 +502,8 @@ export function ScaleBunDebugRoot({
             // measureInWindow returns rootRect.y = statusBarHeight, so subtracting it
             // double-counts the status bar and pushes every marker upward.
             if (rootRect && rootRect.w > 0 && rootRect.h > 0) {
-                const nx = Math.max(0, Math.min(1, touch.pageX / rootRect.w));
-                const ny = Math.max(0, Math.min(1, touch.pageY / rootRect.h));
+                const nx = Math.max(0, Math.min(1, (start?.x ?? touch.pageX) / rootRect.w));
+                const ny = Math.max(0, Math.min(1, (start?.y ?? touch.pageY) / rootRect.h));
                 gestureDetails.normalizedX = nx;
                 gestureDetails.normalizedY = ny;
                 gestureDetails.normalizedPrecomputed = true;
@@ -472,7 +540,7 @@ export function ScaleBunDebugRoot({
                 const dx = touch.pageX - start.x;
                 const dy = touch.pageY - start.y;
                 const dist = Math.sqrt(dx * dx + dy * dy);
-                const duration = Date.now() - start.ts;
+                const duration = Date.now() - start.occurredAt;
                 gestureDetails.duration = duration;
 
                 if (dist >= 15) {
@@ -494,66 +562,17 @@ export function ScaleBunDebugRoot({
                 }
             }
 
-            const targetInfo = _extractTarget(e);
-            gestureDetails.target = targetInfo?.testId || targetInfo?.accessibilityLabel;
-
-            if (captureAutomaticInteractions) {
-                let screen: string | undefined;
-                try {
-                    const { AutoScreenDetector } = require('../navigation/AutoScreenDetector');
-                    screen = AutoScreenDetector.getInstance().getCurrentScreen() || undefined;
-                } catch { /* no-throw */ }
-                /**
-                 * UI STATE, read HERE and not later.
-                 *
-                 * A tap belongs to the surface that was on screen when the finger landed: tapping the
-                 * filter button while the sheet is DOWN belongs to `closed`, because that is what the
-                 * user was looking at when they reached for it. Reading it after the handler has run
-                 * moves every "open the thing" tap into the state it created — the one state it
-                 * certainly does not belong to.
-                 *
-                 * Declared-only on this platform (see uiState.ts): absent means not captured, which
-                 * the dashboard keeps distinct from "nothing was open".
-                 */
-                let ui: string | undefined;
-                try {
-                    const { uiStateSignature } = require('./uiState');
-                    ui = uiStateSignature();
-                } catch { /* no-throw: a tap must never be lost to state capture */ }
-                emitAutomaticEvent('element_interacted', {
-                    gesture_type: gestureType,
-                    screen_name: screen,
-                    /* THIS MAP ENUMERATES. A field added to the payload and forgotten here reaches the
-                       backend as undefined with no error anywhere — the recurring defect class in this
-                       codebase. `ui` is the key the grid aggregate reads for state, byte-identical to
-                       the web SDK's, so one dashboard control queries both platforms. */
-                    ui,
-                    // testID/nativeID is an author-controlled stable identifier.
-                    // Accessibility labels and rendered text are deliberately omitted.
-                    target_id: targetInfo?.testId,
-                    normalized_x: gestureDetails.normalizedX,
-                    normalized_y: gestureDetails.normalizedY,
-                    direction: gestureDetails.direction,
-                    duration_ms: gestureDetails.duration,
-                });
-            }
-
             // Feed the Engage gesture detector (rage_tap / dead_tap) — only committed
             // taps, not swipes/scrolls/long-presses. Pure JS, cross-platform; emits the
             // unified `$gesture` signal the engage trigger engine listens for.
             if (gestureType === 'tap') {
                 try {
                     const { gestureTriggerDetector } = require('../engage/gestureTriggerDetector');
-                    let screen: string | undefined;
-                    try {
-                        const { AutoScreenDetector } = require('../navigation/AutoScreenDetector');
-                        screen = AutoScreenDetector.getInstance().getCurrentScreen() || undefined;
-                    } catch { /* no-throw */ }
                     gestureTriggerDetector.recordTap({
-                        x: touch.pageX,
-                        y: touch.pageY,
-                        hasTarget: !!(targetInfo?.testId || targetInfo?.accessibilityLabel),
-                        screen,
+                        x: start?.x ?? touch.pageX,
+                        y: start?.y ?? touch.pageY,
+                        hasTarget: !!(start?.targetId || start?.target),
+                        screen: start?.screenName,
                     });
                 } catch { /* no-throw */ }
             }
@@ -568,7 +587,7 @@ export function ScaleBunDebugRoot({
             // screenshot capture view). Three-tier suppression:
             //   1. Native confirmed active → skip JS entirely (native handles all touches)
             //   2. Native event within 300ms → skip (existing dedup)
-            //   3. First touch (native not yet confirmed) → defer 200ms to let native arrive
+            //   3. First touch (native not yet confirmed) → defer 600ms to let native arrive
             const sinceNative = Date.now() - lastNativeTouchTsRef.current;
             if (nativeTrackingConfirmedRef.current) {
                 // Native tracker is active — skip JS path entirely
@@ -579,11 +598,9 @@ export function ScaleBunDebugRoot({
                 // If native fires during the delay, it cancels this pending emit.
                 const capturedType = gestureType;
                 const capturedDetails = { ...gestureDetails };
-                if (pendingJsEmitRef.current !== null) {
-                    clearTimeout(pendingJsEmitRef.current);
-                }
-                pendingJsEmitRef.current = setTimeout(() => {
-                    pendingJsEmitRef.current = null;
+                const interactionId = capturedDetails.interactionId as string;
+                const timer = setTimeout(() => {
+                    pendingJsEmitsRef.current.delete(interactionId);
                     if (nativeTrackingConfirmedRef.current) return;
                     try {
                         const { SessionManager } = require('../session/SessionManager');
@@ -605,6 +622,7 @@ export function ScaleBunDebugRoot({
                     // devices with no native tracker at all it merely delays a background emission,
                     // which nothing user-visible waits on.
                 }, 600);
+                pendingJsEmitsRef.current.set(interactionId, timer);
             }
 
             touchStartRef.current = null;
@@ -724,25 +742,6 @@ export function useScaleBunScreen(name: string): void {
     }, [name, manager]);
 }
 
-// ─── Helpers ────────────────────────────────────────────────────────────────
-
-function _extractTarget(e: any): { testId?: string; accessibilityLabel?: string; text?: string } | undefined {
-    try {
-        const target = e?.target;
-        if (!target) return undefined;
-
-        // React Native nativeEvent target properties
-        const props = target._internalFiberInstanceHandleDEV?.memoizedProps ?? {};
-        return {
-            testId: props.testID || props.nativeID || undefined,
-            accessibilityLabel: props.accessibilityLabel || undefined,
-            text: undefined,
-        };
-    } catch {
-        return undefined;
-    }
-}
-
 // ─── Styles ─────────────────────────────────────────────────────────────────
 // IMPORTANT: Do NOT use StyleSheet.create() here.
 // In RN 0.84 bridgeless mode, StyleSheet.create() calls

package/src/features/journey/interactionProtocol.ts

@@ -0,0 +1,65 @@
+/** One physical interaction, shared by replay and analytics projections. */
+export const INTERACTION_PROTOCOL_VERSION = 1;
+
+export type InteractionStateStatus =
+    | 'captured_empty'
+    | 'captured_nonempty'
+    | 'not_captured'
+    | 'not_instrumented';
+
+export interface InteractionStartContext {
+    interactionId: string;
+    occurredAt: number;
+    x: number;
+    y: number;
+    target?: string;
+    targetId?: string;
+    screenName?: string;
+    ui?: string;
+    stateStatus: InteractionStateStatus;
+    emitAutomaticAnalytics: boolean;
+}
+
+export function generateInteractionId(): string {
+    return `ixj-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+/** Match a native bridge event to the JS evidence sampled at the same finger-down. */
+export function nearestInteractionStart<T extends InteractionStartContext>(
+    starts: readonly T[],
+    occurredAt: number,
+    toleranceMs = 1500,
+): T | undefined {
+    let best: T | undefined;
+    let bestDelta = toleranceMs + 1;
+    for (const start of starts) {
+        const delta = Math.abs(start.occurredAt - occurredAt);
+        if (delta < bestDelta) {
+            best = start;
+            bestDelta = delta;
+        }
+    }
+    return bestDelta <= toleranceMs ? best : undefined;
+}
+
+/** Analytics is a projection of the same evidence; no second click is invented. */
+export function automaticInteractionProperties(
+    payload: Record<string, unknown>,
+    screenName: string | undefined,
+    canonicalMirror: boolean,
+): Record<string, unknown> {
+    return {
+        gesture_type: payload.gestureType,
+        screen_name: screenName,
+        interaction_id: payload.interaction_id,
+        interaction_protocol: payload.interaction_protocol,
+        state_status: payload.state_status,
+        ui: payload.ui,
+        target_id: payload.target_id,
+        normalized_x: payload.normalizedX,
+        normalized_y: payload.normalizedY,
+        direction: payload.direction,
+        duration_ms: payload.durationMs,
+        canonical_mirror: canonicalMirror || undefined,
+    };
+}

package/src/features/journey/uiState.ts

@@ -76,9 +76,14 @@ export function uiStateSignature(): string | undefined {
   if (!declared.size) return undefined;
   /* SORTED, or the same surface produces different signatures depending on the order the host happened
      to declare things in, and every count fragments into several that mean nothing. */
-  return [...declared.keys()]
+  const pairs = [...declared.keys()]
     .sort()
-    .map((k) => `${k}:${declared.get(k)}`)
-    .join(';')
-    .slice(0, 96);
+    .map((k) => `${k}:${declared.get(k)}`);
+  let signature = '';
+  for (const pair of pairs) {
+    const next = signature ? `${signature};${pair}` : pair;
+    if (next.length > 96) break;
+    signature = next;
+  }
+  return signature || undefined;
 }

package/src/features/ota/OtaEventEmitter.ts

@@ -9,11 +9,17 @@
 // ── Event types ───────────────────────────────────────────────────────────────
 
 export type OtaEventType =
+  /** A check was made against the server. The denominator of the funnel. */
   | 'CHECK'
+  /** The server answered with a bundle for this device — the offer, before any bytes move. */
+  | 'OFFERED'
   | 'DOWNLOAD_STARTED'
   | 'DOWNLOAD_PROGRESS'
   | 'DOWNLOAD_COMPLETE'
+  /** Staged and swapped. Emitted optimistically, BEFORE the bundle has booted. */
   | 'INSTALLED'
+  /** The bundle booted and survived to the healthy mark — the honest activation signal. */
+  | 'BOOT_SUCCESS'
   | 'APPLY_FAILED'
   | 'AUTO_ROLLBACK'
   | 'MANUAL_ROLLBACK';
@@ -21,6 +27,12 @@ export type OtaEventType =
 export interface OtaEvent {
   type: OtaEventType;
   bundleId: string;
+  /**
+   * The release this bundle was served as. Optional because a bundle installed
+   * by an older SDK has no recorded release; present on everything emitted by a
+   * current one, so the delivery funnel can key by release rather than bundle.
+   */
+  releaseId?: string;
   version?: number;
   /** 0–100 for DOWNLOAD_PROGRESS */
   progress?: number;