@scalebun/react-native 1.10.7 → 1.11.0

package/lib/typescript/features/journey/interactionProtocol.d.ts

@@ -0,0 +1,21 @@
+/** One physical interaction, shared by replay and analytics projections. */
+export declare 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 declare function generateInteractionId(): string;
+/** Match a native bridge event to the JS evidence sampled at the same finger-down. */
+export declare function nearestInteractionStart<T extends InteractionStartContext>(starts: readonly T[], occurredAt: number, toleranceMs?: number): T | undefined;
+/** Analytics is a projection of the same evidence; no second click is invented. */
+export declare function automaticInteractionProperties(payload: Record<string, unknown>, screenName: string | undefined, canonicalMirror: boolean): Record<string, unknown>;
+//# sourceMappingURL=interactionProtocol.d.ts.map

package/lib/typescript/features/session/JourneyEventPipeline.d.ts

@@ -50,6 +50,7 @@ export declare class JourneyEventPipeline {
         journeyId?: string;
         /** Frame that was on screen when this happened. Resolved by the caller; see sessionTypes. */
         frameId?: string;
+        timestamp?: number;
     }): JourneyEvent | null;
     /**
      * Anchor a crash event — protect nearby events from eviction.

package/lib/typescript/features/session/SessionManager.d.ts

@@ -17,6 +17,7 @@ import type { DebugTransport } from '../../debug/transport';
 import type { SessionMetadata, SessionReplayConfig, JourneyEventType, JourneyEventSeverity, JourneyEventSource, CrashAnchor, NativeSyncMetadata, SyncDecisionCallback } from './sessionTypes';
 import { type NativeCaptureFn } from './ReplayCaptureManager';
 import type { BackendSessionAdapter } from './BackendSessionAdapter';
+import { type InteractionStateStatus } from '../journey/interactionProtocol';
 export interface SessionManagerConfig {
     sessionReplay?: Partial<SessionReplayConfig>;
     syncPolicy?: SyncDecisionCallback;
@@ -43,15 +44,6 @@ export declare class SessionManager {
      * lane even when no replay recording is active. Additive, opt-in (default off).
      */
     private _captureInteractionHeatmap;
-    /**
-     * Sampling cap for the analytics-lane heatmap emission. Now that capture is
-     * ON by default, an unbounded one-event-per-gesture stream could materially
-     * inflate ingest volume. We cap emitted interactions per analytics-session
-     * window (finalize-scoped per foreground): the first N gestures define the
-     * hotspot shape; the long tail is dropped. Resets when the window changes.
-     */
-    private _heatmapWindowSessionId;
-    private _heatmapWindowCount;
     private session;
     private active;
     private timeoutTimer;
@@ -207,6 +199,8 @@ export declare class SessionManager {
         traceId?: string;
         source?: JourneyEventSource;
         journeyId?: string;
+        /** Original observation time; interaction capture may resolve asynchronously. */
+        timestamp?: number;
     }): void;
     /**
      * Anchor a crash in the session context.
@@ -223,7 +217,10 @@ export declare class SessionManager {
      * Notify of a user interaction. Called by ScaleBunDebugRoot touch handlers.
      * Also triggers frame capture for desktop-initiated recordings.
      */
-    onUserAction(subtype: string, payload?: Record<string, unknown>): void;
+    onUserAction(subtype: string, payload?: Record<string, unknown>, context?: {
+        screen?: string;
+        timestamp?: number;
+    }): void;
     /**
      * Detailed gesture detection — called by ScaleBunDebugRoot touch handlers.
      * Emits a USER_ACTION event with gesture-specific subtype and payload.
@@ -263,6 +260,14 @@ export declare class SessionManager {
         screenWidth?: number;
         screenHeight?: number;
         platform?: string;
+        interactionId?: string;
+        interactionProtocol?: number;
+        occurredAt?: number;
+        ui?: string;
+        stateStatus?: InteractionStateStatus;
+        targetId?: string;
+        screenName?: string;
+        emitAutomaticAnalytics?: boolean;
     }): void;
     /**
      * Manual frame capture — triggered by Desktop "Capture Step" button.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scalebun/react-native",
-  "version": "1.10.7",
+  "version": "1.11.0",
   "description": "React Native SDK for ScaleBun",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -154,6 +154,7 @@
     "watch": "bob build --watch",
     "test:screens": "node --experimental-transform-types --import ./scripts/rn-globals.mjs --import ./scripts/register-ts-ext.mjs --test scripts/screen-detection.test.ts",
     "test:uistate": "node --experimental-transform-types --import ./scripts/rn-globals.mjs --import ./scripts/register-ts-ext.mjs --test scripts/ui-state.test.ts",
-    "typecheck:scripts": "tsc --noEmit -p tsconfig.scripts.json"
+    "typecheck:scripts": "tsc --noEmit -p tsconfig.scripts.json",
+    "test:protocol": "node --experimental-transform-types --import ./scripts/rn-globals.mjs --import ./scripts/register-ts-ext.mjs --test scripts/interaction-protocol.test.ts"
   }
 }

package/src/analytics/EventTracker.ts

@@ -172,7 +172,7 @@ export class EventTracker {
         this.started = true;
         if (this.cfg.automaticEventTracking) {
             this.automaticEventsUnsubscribe = subscribeAutomaticEvents((event) => {
-                this.track(event.name, event.properties);
+                this.track(event.name, event.properties, event.timestamp);
             });
         }
         if (this.cfg.autoLifecycleEvents) {
@@ -284,9 +284,9 @@ export class EventTracker {
 
     // ─── tracking ────────────────────────────────────────────────────────────
 
-    track(eventName: string, properties?: Record<string, any>): void {
+    track(eventName: string, properties?: Record<string, any>, timestamp?: number): void {
         try {
-            this.enqueue(this.buildEnvelope(eventName, properties));
+            this.enqueue(this.buildEnvelope(eventName, properties, timestamp));
             try { this.cfg.onEvent?.(eventName); } catch { /* no-throw */ }
         } catch (err) {
             logger.warn(`[ScaleBun.events] track failed: ${(err as Error)?.message}`);
@@ -408,7 +408,7 @@ export class EventTracker {
 
     // ─── internals ─────────────────────────────────────────────────────────────
 
-    private buildEnvelope(eventName: string, properties?: Record<string, any>): Envelope {
+    private buildEnvelope(eventName: string, properties?: Record<string, any>, timestamp?: number): Envelope {
         const ctx = this.cfg.context ?? {};
         let canonicalSessionId: string | null | undefined;
         try {
@@ -419,7 +419,7 @@ export class EventTracker {
         const env: Envelope = {
             event_id: uuid(),
             event_name: eventName,
-            event_time: Date.now(),
+            event_time: timestamp ?? Date.now(),
             app_id: this.cfg.appId,
             platform: this.cfg.platform ?? resolveEventPlatform(),
             installation_id: this.installationId,

package/src/analytics/automaticEvents.ts

@@ -39,6 +39,8 @@ export type AutomaticEventName =
 export interface AutomaticEvent {
     name: AutomaticEventName;
     properties: Record<string, unknown>;
+    /** Original observation time. Delivery can be delayed while native coordinates resolve. */
+    timestamp?: number;
 }
 
 type AutomaticEventListener = (event: AutomaticEvent) => void;
@@ -60,10 +62,12 @@ function compactProperties(
 export function emitAutomaticEvent(
     name: AutomaticEventName,
     properties?: Record<string, unknown>,
+    timestamp?: number,
 ): void {
     const event: AutomaticEvent = {
         name,
         properties: compactProperties(properties),
+        timestamp,
     };
     if (listeners.size === 0) {
         pending.push(event);

package/src/core/constants/version.ts

@@ -1,6 +1,11 @@
 /**
  * ScaleBun SDK version. Sent with the session-start envelope so the dashboard
  * can attribute telemetry to the SDK build that produced it.
- * Keep in sync with package.json "version".
+ * Keep in sync with package.json "version" — `version.test.ts` fails when they drift.
+ *
+ * Why the test matters: the 1.11.0 bump missed this line, so the build would have reported itself as
+ * 1.10.6. Every "is the release live, and on what share of traffic" question is answered from this
+ * value, so a stale one makes a rollout unobservable — which is the exact problem sending an SDK
+ * version was introduced to solve.
  */
-export const SDK_VERSION = '1.10.7';
+export const SDK_VERSION = '1.11.0';

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/session/JourneyEventPipeline.ts

@@ -93,31 +93,33 @@ export class JourneyEventPipeline {
             journeyId?: string;
             /** Frame that was on screen when this happened. Resolved by the caller; see sessionTypes. */
             frameId?: string;
+            timestamp?: number;
         },
     ): JourneyEvent | null {
         try {
             const key = `${type}:${opts?.subtype ?? ''}`;
-            const now = Date.now();
-            if (key === this.lastEventKey && (now - this.lastEventTs) < this.config.dedupeWindowMs) {
+            const receivedAt = Date.now();
+            const occurredAt = opts?.timestamp ?? receivedAt;
+            if (key === this.lastEventKey && (receivedAt - this.lastEventTs) < this.config.dedupeWindowMs) {
                 // Within dedup window — allow high-confidence native events to
                 // REPLACE a prior low-confidence JS event for the same gesture.
                 // This prevents the race where JS fires first and the pipeline
                 // drops the native event that has more accurate coordinates.
                 const incomingConfidence = (opts?.payload as any)?.confidence;
                 if (incomingConfidence === 'high' && this.lastEventConfidence !== 'high') {
-                    this._replaceLastEvent(key, now, opts);
+                    this._replaceLastEvent(key, receivedAt, opts);
                 }
                 return null;
             }
             this.lastEventKey = key;
-            this.lastEventTs = now;
+            this.lastEventTs = receivedAt;
             this.lastEventConfidence = (opts?.payload as any)?.confidence ?? null;
 
             const event: JourneyEvent = {
                 eventId: generateEventId(),
                 sessionId: this.sessionId,
                 journeyId: opts?.journeyId,
-                ts: now,
+                ts: occurredAt,
                 type,
                 subtype: opts?.subtype,
                 severity: opts?.severity ?? inferSeverity(type),