@scalebun/react-native 1.10.6 → 1.11.0

package/ios/Capture/InteractionTracker.swift

@@ -17,8 +17,8 @@ class InteractionTracker: NSObject, UIGestureRecognizerDelegate {
 
     private var touchDownLocation: CGPoint = .zero
     private var touchDownTime: TimeInterval = 0
-    private var lastEmitTime: TimeInterval = 0
-    private let throttleInterval: TimeInterval = 0.15
+    private var touchInteractionId = ""
+    private var lastEmittedInteractionId = ""
 
     func attach(to window: UIWindow, sendEvent: @escaping (String, [String: Any]) -> Void) {
         guard !isActive else { return }
@@ -29,6 +29,7 @@ class InteractionTracker: NSObject, UIGestureRecognizerDelegate {
             onBegan: { [weak self] location in
                 self?.touchDownLocation = location
                 self?.touchDownTime = Date().timeIntervalSince1970
+                self?.touchInteractionId = "ixn-i-\(UUID().uuidString.lowercased())"
             },
             onEnded: { [weak self] location in
                 self?.handleTouchEnded(at: location, in: window)
@@ -55,8 +56,8 @@ class InteractionTracker: NSObject, UIGestureRecognizerDelegate {
 
     private func handleTouchEnded(at location: CGPoint, in window: UIWindow) {
         let now = Date().timeIntervalSince1970
-        guard now - lastEmitTime >= throttleInterval else { return }
-        lastEmitTime = now
+        guard touchInteractionId != lastEmittedInteractionId else { return }
+        lastEmittedInteractionId = touchInteractionId
 
         let durationMs = (now - touchDownTime) * 1000
         let dx = location.x - touchDownLocation.x
@@ -104,6 +105,9 @@ class InteractionTracker: NSObject, UIGestureRecognizerDelegate {
 
         let event: [String: Any] = [
             "gestureType": gestureType,
+            "interactionId": touchInteractionId,
+            "interactionProtocol": 1,
+            "occurredAt": touchDownTime * 1000,
             "rawX": downInCapture.x,
             "rawY": downInCapture.y,
             "normalizedX": nX,

package/ios/Ota/ScaleBunOtaBridge.mm

@@ -40,6 +40,12 @@ RCT_EXTERN_METHOD(revertToPrevious:(RCTPromiseResolveBlock)resolve
 
 RCT_EXTERN_METHOD(restartApp)
 
+RCT_EXTERN_METHOD(verifyEd25519:(NSString *)messageHex
+                  signatureHex:(NSString *)signatureHex
+                  publicKeyHex:(NSString *)publicKeyHex
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
 @end
 
 // Download-progress event channel. Swift subclass of RCTEventEmitter; only

package/ios/Ota/ScaleBunOtaModule.swift

@@ -1,6 +1,7 @@
 import Foundation
 import React
 import CommonCrypto
+import CryptoKit
 
 /**
  * React Native bridge for OTA bundle management (`ScaleBunOta`) on iOS.
@@ -252,4 +253,70 @@ class ScaleBunOtaModule: NSObject, RCTBridgeModule {
             RCTTriggerReloadCommandListeners("ScaleBun OTA update")
         }
     }
+
+    /**
+     * Verify a detached ed25519 signature with PLATFORM crypto (CryptoKit).
+     *
+     * Why native: the JS verifier lives inside the very bundle it protects —
+     * one malicious bundle can neuter it for every update after. CryptoKit is
+     * outside the bundle's reach, and unlike Android there is no OS floor to
+     * worry about: Curve25519 signing shipped in iOS 13 and the podspec
+     * already requires 13.4.
+     *
+     * Contract (mirrors `src/specs/NativeScaleBunOta.ts`): inputs are
+     * lowercase hex pre-validated by the JS caller; the message is the RAW 32
+     * BYTES of the bundle SHA-256 (the CLI signs digest bytes, not hex text);
+     * resolves 'valid' / 'invalid' / 'unavailable'. A wrong signature is
+     * 'invalid', never a rejection; anything unexpected is 'unavailable' so
+     * machinery failure can never read as a pass.
+     *
+     * ⚪ UNCOMPILED — no macOS toolchain has been available in this workspace
+     * (the standing gap: BsPatch.swift shipped the same way). The algorithm is
+     * pinned by `tools/ed25519-parity` against the live production fixture;
+     * this file still needs one Xcode build before an iOS consumer ships it.
+     */
+    @objc(verifyEd25519:signatureHex:publicKeyHex:resolve:reject:)
+    func verifyEd25519(_ messageHex: NSString,
+                       signatureHex: NSString,
+                       publicKeyHex: NSString,
+                       resolve: @escaping RCTPromiseResolveBlock,
+                       reject: @escaping RCTPromiseRejectBlock) {
+        guard let message = ScaleBunOtaModule.bytesFromHex(messageHex as String),
+              let signature = ScaleBunOtaModule.bytesFromHex(signatureHex as String),
+              let rawKey = ScaleBunOtaModule.bytesFromHex(publicKeyHex as String),
+              rawKey.count == 32 else {
+            // Malformed input from our own caller is not a forgery verdict.
+            resolve("unavailable")
+            return
+        }
+        do {
+            let key = try Curve25519.Signing.PublicKey(rawRepresentation: rawKey)
+            resolve(key.isValidSignature(signature, for: message) ? "valid" : "invalid")
+        } catch {
+            // Bytes that are not a curve point cannot have signed anything.
+            resolve("invalid")
+        }
+    }
+
+    /// Hex → Data; nil for odd length or a non-hex character.
+    private static func bytesFromHex(_ hex: String) -> Data? {
+        let chars = Array(hex.utf8)
+        guard !chars.isEmpty, chars.count % 2 == 0 else { return nil }
+        var out = Data(capacity: chars.count / 2)
+        for i in stride(from: 0, to: chars.count, by: 2) {
+            guard let hi = ScaleBunOtaModule.hexNibble(chars[i]),
+                  let lo = ScaleBunOtaModule.hexNibble(chars[i + 1]) else { return nil }
+            out.append((hi << 4) | lo)
+        }
+        return out
+    }
+
+    private static func hexNibble(_ c: UInt8) -> UInt8? {
+        switch c {
+        case 0x30...0x39: return c - 0x30            // 0-9
+        case 0x61...0x66: return c - 0x61 + 10       // a-f
+        case 0x41...0x46: return c - 0x41 + 10       // A-F
+        default: return nil
+        }
+    }
 }

package/lib/commonjs/analytics/EventTracker.js

@@ -103,7 +103,7 @@ class EventTracker {
     this.started = true;
     if (this.cfg.automaticEventTracking) {
       this.automaticEventsUnsubscribe = (0, _automaticEvents.subscribeAutomaticEvents)(event => {
-        this.track(event.name, event.properties);
+        this.track(event.name, event.properties, event.timestamp);
       });
     }
     if (this.cfg.autoLifecycleEvents) {
@@ -226,9 +226,9 @@ class EventTracker {
 
   // ─── tracking ────────────────────────────────────────────────────────────
 
-  track(eventName, properties) {
+  track(eventName, properties, timestamp) {
     try {
-      this.enqueue(this.buildEnvelope(eventName, properties));
+      this.enqueue(this.buildEnvelope(eventName, properties, timestamp));
       try {
         this.cfg.onEvent?.(eventName);
       } catch {/* no-throw */}
@@ -365,7 +365,7 @@ class EventTracker {
 
   // ─── internals ─────────────────────────────────────────────────────────────
 
-  buildEnvelope(eventName, properties) {
+  buildEnvelope(eventName, properties, timestamp) {
     const ctx = this.cfg.context ?? {};
     let canonicalSessionId;
     try {
@@ -376,7 +376,7 @@ class EventTracker {
     const env = {
       event_id: uuid(),
       event_name: eventName,
-      event_time: Date.now(),
+      event_time: timestamp ?? Date.now(),
       app_id: this.cfg.appId,
       platform: this.cfg.platform ?? (0, _device.resolveEventPlatform)(),
       installation_id: this.installationId,

package/lib/commonjs/analytics/automaticEvents.js

@@ -27,10 +27,11 @@ function compactProperties(properties) {
   }
   return out;
 }
-function emitAutomaticEvent(name, properties) {
+function emitAutomaticEvent(name, properties, timestamp) {
   const event = {
     name,
-    properties: compactProperties(properties)
+    properties: compactProperties(properties),
+    timestamp
   };
   if (listeners.size === 0) {
     pending.push(event);

package/lib/commonjs/core/config/schema.js

@@ -295,6 +295,14 @@ const SHAPE = {
         kind: 'str',
         opt: true
       },
+      // Rotation support: several pinned keys, any of which may verify a
+      // bundle. Ship a build pinning [old, new], re-sign server-side with
+      // new, drop old next release — no emergency store submission when a
+      // key must be replaced. Merged with publicSigningKey by the facade.
+      publicSigningKeys: {
+        kind: 'strArr',
+        opt: true
+      },
       mandatoryBlocksUi: bool(false)
     }
   }
@@ -334,7 +342,7 @@ function parseField(field, input, path, issues) {
       present: true
     };
     // Required with no default (matches the base schemas' type errors on undefined).
-    return fail(field.kind === 'bool' ? 'Expected boolean, received undefined' : field.kind === 'num' ? 'Expected number, received undefined' : field.kind === 'str' ? 'Expected string, received undefined' : field.kind === 'enum' ? "Invalid enum value. Expected " + field.values.map(v => `'${v}'`).join(' | ') : 'Expected object, received undefined');
+    return fail(field.kind === 'bool' ? 'Expected boolean, received undefined' : field.kind === 'num' ? 'Expected number, received undefined' : field.kind === 'str' ? 'Expected string, received undefined' : field.kind === 'strArr' ? 'Expected array, received undefined' : field.kind === 'enum' ? "Invalid enum value. Expected " + field.values.map(v => `'${v}'`).join(' | ') : 'Expected object, received undefined');
   }
   switch (field.kind) {
     case 'any':
@@ -360,6 +368,31 @@ function parseField(field, input, path, issues) {
         value: input,
         present: true
       };
+    case 'strArr':
+      {
+        // Mirrors the vendored ArraySchema exactly: element failures are
+        // reported at their index and fail the whole field (no partial
+        // arrays reach the output).
+        if (!Array.isArray(input)) return fail(`Expected array, received ${typeofName(input)}`);
+        let allOk = true;
+        for (let i = 0; i < input.length; i++) {
+          if (typeof input[i] !== 'string') {
+            issues.push({
+              path: [...path, i],
+              message: `Expected string, received ${typeofName(input[i])}`
+            });
+            allOk = false;
+          }
+        }
+        return allOk ? {
+          ok: true,
+          value: [...input],
+          present: true
+        } : {
+          ok: false,
+          present: true
+        };
+      }
     case 'num':
       if (typeof input !== 'number' || Number.isNaN(input)) {
         return fail(`Expected number, received ${typeofName(input)}`);

package/lib/commonjs/core/constants/version.js

@@ -7,7 +7,12 @@ exports.SDK_VERSION = void 0;
 /**
  * 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.
  */
-const SDK_VERSION = exports.SDK_VERSION = '1.10.6';
+const SDK_VERSION = exports.SDK_VERSION = '1.11.0';
 //# sourceMappingURL=version.js.map

package/lib/commonjs/features/journey/ScaleBunDebugRoot.js

@@ -8,9 +8,9 @@ exports.ScaleBunScreen = ScaleBunScreen;
 exports.useScaleBunScreen = useScaleBunScreen;
 var _react = _interopRequireWildcard(require("react"));
 var _reactNative = require("react-native");
-var _automaticEvents = require("../../analytics/automaticEvents");
 var _touchTarget = require("./touchTarget");
 var _device = require("../../core/context/device");
+var _interactionProtocol = require("./interactionProtocol");
 var _jsxRuntime = require("react/jsx-runtime");
 function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 /**
@@ -264,7 +264,9 @@ function ScaleBunDebugRoot({
   // and forwards them to SessionManager as USER_ACTION events.
   const lastNativeTouchTsRef = (0, _react.useRef)(0);
   const nativeTrackingConfirmedRef = (0, _react.useRef)(false);
-  const pendingJsEmitRef = (0, _react.useRef)(null);
+  const touchStartRef = (0, _react.useRef)(null);
+  const interactionStartsRef = (0, _react.useRef)([]);
+  const pendingJsEmitsRef = (0, _react.useRef)(new Map());
   (0, _react.useEffect)(() => {
     let subscription = null;
     try {
@@ -276,11 +278,15 @@ function ScaleBunDebugRoot({
           // Record timestamp to suppress duplicate JS touch events
           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 = (0, _interactionProtocol.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
@@ -302,6 +308,15 @@ function ScaleBunDebugRoot({
             _diagWinH = _d.height;
           } catch {/* no-throw */}
           sm.onGestureDetected(event.gestureType || 'tap', {
+            interactionId: event.interactionId || start?.interactionId || (0, _interactionProtocol.generateInteractionId)(),
+            interactionProtocol: event.interactionProtocol || _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
@@ -331,11 +346,12 @@ function ScaleBunDebugRoot({
       try {
         subscription?.remove();
       } catch {/* no-throw */}
+      for (const timer of pendingJsEmitsRef.current.values()) clearTimeout(timer);
+      pendingJsEmitsRef.current.clear();
     };
-  }, []);
+  }, [captureAutomaticInteractions]);
 
   // ─── Touch Tracking State ───────────────────────────────────────────
-  const touchStartRef = (0, _react.useRef)(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
@@ -379,11 +395,37 @@ function ScaleBunDebugRoot({
   const handleTouchStart = e => {
     try {
       const touch = e.nativeEvent;
-      touchStartRef.current = {
+      const target = (0, _touchTarget.resolveTouchTarget)(e);
+      let ui;
+      let screenName;
+      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 = {
+        interactionId: (0, _interactionProtocol.generateInteractionId)(),
+        occurredAt: Date.now(),
         x: touch.pageX,
         y: touch.pageY,
-        ts: Date.now()
+        locationX: touch.locationX,
+        locationY: touch.locationY,
+        target: (0, _touchTarget.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 */}
   };
   const handleTouchEnd = e => {
@@ -422,15 +464,23 @@ 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 = (0, _touchTarget.describeTouchTarget)((0, _touchTarget.resolveTouchTarget)(e));
+      const tapped = start?.target ?? (0, _touchTarget.describeTouchTarget)((0, _touchTarget.resolveTouchTarget)(e));
       const gestureDetails = {
         target: tapped,
-        x: touch.pageX,
-        y: touch.pageY,
-        pageX: touch.pageX,
-        pageY: touch.pageY,
-        locationX: touch.locationX,
-        locationY: touch.locationY,
+        interactionId: start?.interactionId ?? (0, _interactionProtocol.generateInteractionId)(),
+        interactionProtocol: _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
       };
@@ -442,8 +492,8 @@ 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;
@@ -475,7 +525,7 @@ 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) {
           // Movement gesture: swipe or scroll
@@ -494,28 +544,6 @@ function ScaleBunDebugRoot({
           gestureType = 'long_press';
         }
       }
-      const targetInfo = _extractTarget(e);
-      gestureDetails.target = targetInfo?.testId || targetInfo?.accessibilityLabel;
-      if (captureAutomaticInteractions) {
-        let screen;
-        try {
-          const {
-            AutoScreenDetector
-          } = require('../navigation/AutoScreenDetector');
-          screen = AutoScreenDetector.getInstance().getCurrentScreen() || undefined;
-        } catch {/* no-throw */}
-        (0, _automaticEvents.emitAutomaticEvent)('element_interacted', {
-          gesture_type: gestureType,
-          screen_name: screen,
-          // 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
@@ -525,18 +553,11 @@ function ScaleBunDebugRoot({
           const {
             gestureTriggerDetector
           } = require('../engage/gestureTriggerDetector');
-          let screen;
-          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 */}
       }
@@ -551,7 +572,7 @@ 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
@@ -564,11 +585,9 @@ function ScaleBunDebugRoot({
         const capturedDetails = {
           ...gestureDetails
         };
-        if (pendingJsEmitRef.current !== null) {
-          clearTimeout(pendingJsEmitRef.current);
-        }
-        pendingJsEmitRef.current = setTimeout(() => {
-          pendingJsEmitRef.current = null;
+        const interactionId = capturedDetails.interactionId;
+        const timer = setTimeout(() => {
+          pendingJsEmitsRef.current.delete(interactionId);
           if (nativeTrackingConfirmedRef.current) return;
           try {
             const {
@@ -592,6 +611,7 @@ 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;
     } catch {/* no-throw */}
@@ -706,25 +726,6 @@ function useScaleBunScreen(name) {
   }, [name, manager]);
 }
 
-// ─── Helpers ────────────────────────────────────────────────────────────────
-
-function _extractTarget(e) {
-  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/lib/commonjs/features/journey/interactionProtocol.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.INTERACTION_PROTOCOL_VERSION = void 0;
+exports.automaticInteractionProperties = automaticInteractionProperties;
+exports.generateInteractionId = generateInteractionId;
+exports.nearestInteractionStart = nearestInteractionStart;
+/** One physical interaction, shared by replay and analytics projections. */
+const INTERACTION_PROTOCOL_VERSION = exports.INTERACTION_PROTOCOL_VERSION = 1;
+function generateInteractionId() {
+  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. */
+function nearestInteractionStart(starts, occurredAt, toleranceMs = 1500) {
+  let best;
+  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. */
+function automaticInteractionProperties(payload, screenName, canonicalMirror) {
+  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
+  };
+}
+//# sourceMappingURL=interactionProtocol.js.map