@everframe/react-native 1.2.1 → 1.4.0

package/ios/Sources/EverframeBridge.swift

@@ -30,6 +30,7 @@ import CoreFoundation
 import Combine
 import os.log
 import UIKit
+import EverframeProtocol
 import EverframeKit
 import EverframeReporterUI    // tvOS slice present per Package.swift:12 (TV-03 of Phase 06.1)
 
@@ -68,7 +69,10 @@ import EverframeReporterUI    // tvOS slice present per Package.swift:12 (TV-03
         releaseHealthLoadedBuildId: NSString?,
         releaseHealthUserId: NSString?,
         releaseHealthIncludeDebugBuilds: Bool,
-        reporterDisabled: Bool = false
+        jsBundleBuildId: NSString? = nil,
+        jsBundleName: NSString? = nil,
+        reporterDisabled: Bool = false,
+        interactionsJson: NSString? = nil
     ) throws {
         configureLock.lock()
         defer { configureLock.unlock() }
@@ -80,6 +84,8 @@ import EverframeReporterUI    // tvOS slice present per Package.swift:12 (TV-03
         // Polarity flips exactly once, here: JS sends the veto
         // (`networkBodiesDisabled`), native stores the permission.
         var cfg = EverframeConfig(sdkKey: sdkKey as String)
+        cfg.interactions = InteractionEventPolicy.parse(interactionsJson as String?)
+        cfg.loadedJsBundle = LoadedJsBundle(buildId: jsBundleBuildId as String?, bundleName: jsBundleName as String?)
         cfg.capture.networkBodies = !networkBodiesDisabled
         // Polarity flips exactly once, here: JS sends the veto
         // (`installIdentifierDisabled`), native stores the permission —
@@ -537,6 +543,11 @@ import EverframeReporterUI    // tvOS slice present per Package.swift:12 (TV-03
     @objc public static func openReporter(
         completion: @escaping (NSDictionary?, NSError?) -> Void
     ) {
+        openReporter(trigger: "button", completion: completion)
+    }
+
+    @objc(openReporterWithTrigger:completion:)
+    public static func openReporter(trigger: String, completion: @escaping (NSDictionary?, NSError?) -> Void) {
         os_log("[everframe] openReporter.enter", log: log, type: .info)
         guard Everframe.shared.captureGate else {
             completion(nil, NSError(
@@ -553,7 +564,7 @@ import EverframeReporterUI    // tvOS slice present per Package.swift:12 (TV-03
 
         Task {
             do {
-                let result = try await Everframe.shared.report.open()
+                let result = try await Everframe.shared.report.open(trigger: ReporterTrigger(rawValue: trigger) ?? .button)
                 let dict: NSDictionary
                 switch result {
                 case .submitted(let id):
@@ -575,6 +586,15 @@ import EverframeReporterUI    // tvOS slice present per Package.swift:12 (TV-03
         }
     }
 
+    @objc public static func markReporterOpened(_ trigger: String, completion: @escaping @Sendable () -> Void) {
+        guard let trigger = ReporterTrigger(rawValue: trigger) else { completion(); return }
+        BreadcrumbRingBuffer.shared.reporterOpened(trigger: trigger, completion: completion)
+    }
+
+    @objc public static func markReporterClosed(_ completion: @escaping @Sendable () -> Void) {
+        BreadcrumbRingBuffer.shared.reporterClosed(completion: completion)
+    }
+
     /// `openReporter`'s error for a crash-only session (`reporterDisabled: true`).
     static let reporterDisabledErrorCode = 1101
 
@@ -712,6 +732,13 @@ import EverframeReporterUI    // tvOS slice present per Package.swift:12 (TV-03
     /// JS facade projects to these three string fields before the bridge
     /// anyway (`src/user-projection.ts`); this is the second layer, aligned in
     /// behaviour with Android's `stringOrNull` helper.
+    @objc public static func setStateSync(_ key: String, valueJson: String) -> Bool {
+        guard valueJson.utf8.count <= 2048, let data = valueJson.data(using: .utf8),
+              let value = try? JSONDecoder().decode(EverframeStateValue.self, from: data) else { return false }
+        return Everframe.shared.setState(key, value: value)
+    }
+    @objc public static func clearStateSync(_ key: String) -> Bool { Everframe.shared.clearState(key) }
+
     @objc public static func setUser(_ user: NSDictionary?) {
         guard let user else {
             Everframe.shared.setUser(nil)

package/ios/Sources/EverframeModule.mm

@@ -63,6 +63,48 @@
 #import "EverframeRN-Swift.h"
 #endif
 
+#import <React/RCTViewComponentView.h>
+#import <react/renderer/components/view/ViewProps.h>
+#import <react/renderer/components/view/accessibilityPropsConversions.h>
+#import <objc/runtime.h>
+#import "RnDevtoolsOrigin.h"
+
+// Fabric clears props and reuses component views. Invalidate before reuse begins.
+@interface RCTViewComponentView (EverframeInteractionTarget)
+@end
+@implementation RCTViewComponentView (EverframeInteractionTarget)
+- (void)ef_target_prepareForRecycle {
+  [RnInteractionTargetRegistration invalidateView:self];
+  [RnInteractionEventRegistration invalidateView:self];
+  [self ef_target_prepareForRecycle];
+}
+@end
+
+// Fabric exposes the native TextInput/Switch accessibility element publicly.
+// ScrollView's public scrollView getter is resolved by the registration layer.
+// Never reach into component-private ivars or replace their delegates.
+static UIView *EFInteractionHost(UIView *view) {
+  if ([view isKindOfClass:RCTViewComponentView.class]) {
+    NSObject *element = [(RCTViewComponentView *)view accessibilityElement];
+    if ([element isKindOfClass:UITextField.class] || [element isKindOfClass:UITextView.class]
+#if !TARGET_OS_TV
+        || [element isKindOfClass:UISwitch.class] || [element isKindOfClass:UISlider.class]
+#endif
+        || [element isKindOfClass:UIScrollView.class]) return (UIView *)element;
+  }
+  return view;
+}
+
+static NSDictionary *EFInteractionHints(UIView *view) {
+  if (![view isKindOfClass:RCTViewComponentView.class]) return nil;
+  const auto props = std::static_pointer_cast<const facebook::react::ViewProps>([(RCTViewComponentView *)view props]);
+  if (!props) return nil;
+  const std::string role = props->role != facebook::react::Role::None
+    ? facebook::react::toString(props->role) : props->accessibilityRole;
+  return @{ @"testId": @(props->testId.c_str()), @"role": @(role.c_str()), @"name": @(props->accessibilityLabel.c_str()),
+            @"actionable": @(props->events[facebook::react::ViewEvents::Offset::Click]) };
+}
+
 @implementation EverframeModule {
   // Strong ref to the bridge so we can look up RCTUIManager later.
   __weak RCTBridge *_bridge;
@@ -73,6 +115,8 @@
   // and let either one's `-invalidate` tear down the other's players. Android's
   // module has always held its registry as an instance field; this matches it.
   RemoteVitalsBridge *_vitals;
+  RnInteractionTargetRegistration *_interactionTargets;
+  RnInteractionEventRegistration *_interactionEvents;
   // D1 fix (stale-teardown identity guard, spec 2026-09-17 setExtra-resolver).
   // Snapshot of `[EverframeBridge currentExtraResolveHookGeneration]` taken
   // right after THIS instance's most recent `-configureSync:` call — see
@@ -84,6 +128,8 @@
   NSInteger _extraResolveHookGeneration;
 }
 
+@synthesize viewRegistry_DEPRECATED = _viewRegistry_DEPRECATED;
+
 RCT_EXPORT_MODULE(Everframe)
 
 - (instancetype)init {
@@ -91,6 +137,16 @@ RCT_EXPORT_MODULE(Everframe)
     // Cheap: the registry allocates one lock and an empty map, nothing more —
     // which is also why `+requiresMainQueueSetup` can stay NO.
     _vitals = [RemoteVitalsBridge new];
+    _interactionEvents = [RnInteractionEventRegistration new];
+    _interactionTargets = [RnInteractionTargetRegistration new];
+    [_interactionTargets installOriginAdapter:^BOOL(UIView *view) { return EFIsDevMenuView(view); }];
+    [_interactionTargets installAdapter:^NSDictionary *(UIView *view) { return EFInteractionHints(view); }];
+    static dispatch_once_t once;
+    dispatch_once(&once, ^{
+      EFInstallDevMenuOrigin();
+      method_exchangeImplementations(class_getInstanceMethod(RCTViewComponentView.class, @selector(prepareForRecycle)),
+                                     class_getInstanceMethod(RCTViewComponentView.class, @selector(ef_target_prepareForRecycle)));
+    });
   }
   return self;
 }
@@ -211,7 +267,10 @@ RCT_EXPORT_MODULE(Everframe)
           releaseHealthLoadedBuildId:opts.releaseHealthLoadedBuildId()
                  releaseHealthUserId:opts.releaseHealthUserId()
      releaseHealthIncludeDebugBuilds:opts.releaseHealthIncludeDebugBuilds().value_or(false)
+                     jsBundleBuildId:opts.jsBundleBuildId()
+                        jsBundleName:opts.jsBundleName()
                     reporterDisabled:reporterDisabled
+                    interactionsJson:opts.interactionsJson()
                                error:&err];
   if (err != nil) {
     // A refused configuration is logged; JS keeps its mount either way.
@@ -223,6 +282,7 @@ RCT_EXPORT_MODULE(Everframe)
   // hand back to `resetExtraResolverForTeardown:`. See that method's doc
   // comment on EverframeBridge.swift for the race this closes.
   _extraResolveHookGeneration = [EverframeBridge currentExtraResolveHookGeneration];
+  if (err == nil) [_interactionTargets onStarted];
   // Codex round-5 — nothing re-registers the live players here any more. `renewAll()` raced
   // the runtime's deferred-registration drain (it could detach the replacement it had just
   // installed) and only ever reached THIS module instance's registry. The replacement is two
@@ -250,6 +310,50 @@ RCT_EXPORT_MODULE(Everframe)
   }];
 }
 
+- (void)openReporterWithTrigger:(NSString *)trigger resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  [EverframeBridge openReporterWithTrigger:trigger completion:^(NSDictionary *result, NSError *err) {
+    if (err) reject([EverframeBridge openReporterRejectCodeFor:err], err.localizedDescription, err);
+    else resolve(result ?: @{});
+  }];
+}
+- (void)markReporterOpened:(NSString *)trigger resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  [EverframeBridge markReporterOpened:trigger completion:^{ resolve(nil); }];
+}
+- (void)markReporterClosed:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject {
+  [EverframeBridge markReporterClosed:^{ resolve(nil); }];
+}
+
+- (NSNumber *)setInteractionTarget:(double)viewTag
+                    registrationId:(NSString *)registrationId
+                         generation:(double)generation
+                         annotation:(NSDictionary *)annotation {
+  __weak RCTViewRegistry *registry = _viewRegistry_DEPRECATED;
+  return @([_interactionTargets setTarget:viewTag registrationId:registrationId generation:generation annotation:annotation
+                                 resolve:^UIView *(NSNumber *tag) {
+    @try { return [registry viewForReactTag:tag]; } @catch (NSException *exception) { return nil; }
+  }]);
+}
+
+- (NSNumber *)clearInteractionTarget:(NSString *)registrationId generation:(double)generation {
+  return @([_interactionTargets clearTarget:registrationId generation:generation]);
+}
+
+- (NSString *)getInteractionLease { return [_interactionEvents lease]; }
+- (NSNumber *)setInteractionObserver:(double)viewTag id:(NSString *)identifier generation:(double)generation
+                               lease:(NSString *)lease optionsJson:(NSString *)optionsJson {
+  __weak RCTViewRegistry *registry = _viewRegistry_DEPRECATED;
+  return @([_interactionEvents setObserver:viewTag id:identifier generation:generation lease:lease optionsJson:optionsJson
+    resolve:^UIView *(NSNumber *tag) {
+      @try { return [registry viewForReactTag:tag]; } @catch (NSException *exception) { return nil; }
+    } host:^UIView *(UIView *view) { return EFInteractionHost(view); }]);
+}
+- (NSNumber *)clearInteractionObserver:(NSString *)identifier generation:(double)generation {
+  return @([_interactionEvents clearObserver:identifier generation:generation]);
+}
+- (NSNumber *)recordInteraction:(NSString *)lease id:(NSString *)identifier generation:(double)generation eventJson:(NSString *)eventJson {
+  return @([_interactionEvents record:lease id:identifier generation:generation eventJson:eventJson]);
+}
+
 // MARK: - registerSensitiveRect(viewTag, rect)
 
 // `viewTag` is `double` per RN codegen rules (numbers cross as double).
@@ -259,15 +363,11 @@ RCT_EXPORT_MODULE(Everframe)
 // available if a future iteration needs hint-based registration.
 - (void)registerSensitiveRect:(double)viewTag
                          rect:(JS::NativeEverframe::Rect &)rect {
-  __weak RCTBridge *weakBridge = _bridge;
+  __weak RCTViewRegistry *registry = _viewRegistry_DEPRECATED;
   NSNumber *tag = @((NSInteger)viewTag);
   dispatch_async(dispatch_get_main_queue(), ^{
-    RCTBridge *strongBridge = weakBridge;
     UIView *view = nil;
-    if (strongBridge != nil) {
-      view = [strongBridge.uiManager viewForReactTag:tag];
-    }
-    // Bridge does a nil-check + warn-once (Pitfall P5 / T-06-02-03).
+    @try { view = [registry viewForReactTag:tag]; } @catch (NSException *exception) { }
     [EverframeBridge markSensitiveViewOrWarn:view];
   });
 }
@@ -395,6 +495,8 @@ RCT_EXPORT_MODULE(Everframe)
 // Provider's configure-on-mount, so clearing there would drop legitimate
 // registrations that had already landed.
 - (void)invalidate {
+  [_interactionEvents close];
+  [_interactionTargets close];
   [_vitals reset];
   // Review finding F4 (spec 2026-09-17 setExtra-resolver) — see
   // `EverframeBridge.resetExtraResolverForTeardown`'s doc comment for why
@@ -428,6 +530,13 @@ RCT_EXPORT_MODULE(Everframe)
 // shape; `id` is compatible with the generated `NSDictionary *` protocol
 // type. `EverframeBridge` re-validates and pulls out id/email/displayName
 // defensively.
+- (NSNumber *)setStateSync:(NSString *)key valueJson:(NSString *)valueJson {
+  return @([EverframeBridge setStateSync:key valueJson:valueJson]);
+}
+- (NSNumber *)clearStateSync:(NSString *)key {
+  return @([EverframeBridge clearStateSync:key]);
+}
+
 - (void)setUser:(id)user {
   NSDictionary *dict = [user isKindOfClass:[NSDictionary class]] ? (NSDictionary *)user : nil;
   [EverframeBridge setUser:dict];

package/ios/Sources/RnDevtoolsOrigin.h

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 ScriptX
+#import <UIKit/UIKit.h>
+
+/// Framework support only; all calls after installation run on the UI thread.
+FOUNDATION_EXPORT void EFInstallDevMenuOrigin(void);
+FOUNDATION_EXPORT BOOL EFIsDevMenuView(UIView *view);

package/ios/Sources/RnDevtoolsOrigin.mm

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 ScriptX
+#import "RnDevtoolsOrigin.h"
+#import <objc/runtime.h>
+#import <cstring>
+
+// RN's developer menu is a generic UIAlertController. Attribute the actual
+// controller owned by RCTDevMenu, never its title or any of its button labels.
+static NSHashTable<id> *EFDevMenus;
+static Ivar EFDevMenuActionSheet;
+void EFInstallDevMenuOrigin(void) {
+  Class cls = NSClassFromString(@"RCTDevMenu");
+  Method method = cls ? class_getInstanceMethod(cls, NSSelectorFromString(@"show")) : NULL;
+  Ivar actionSheet = cls ? class_getInstanceVariable(cls, "_actionSheet") : NULL;
+  if (!method || !actionSheet || strcmp(ivar_getTypeEncoding(actionSheet), "@\"UIAlertController\"") != 0) return;
+  EFDevMenus = [NSHashTable weakObjectsHashTable];
+  EFDevMenuActionSheet = actionSheet;
+  typedef void (*ShowFn)(id, SEL);
+  ShowFn original = (ShowFn)method_getImplementation(method);
+  method_setImplementation(method, imp_implementationWithBlock(^(id menu) {
+    original(menu, NSSelectorFromString(@"show"));
+    if (![NSThread isMainThread]) return;
+    id controller = object_getIvar(menu, actionSheet);
+    if ([controller isKindOfClass:UIViewController.class]) [EFDevMenus addObject:menu];
+  }));
+}
+BOOL EFIsDevMenuView(UIView *view) {
+  for (id menu in EFDevMenus) {
+    id current = object_getIvar(menu, EFDevMenuActionSheet);
+    if (![current isKindOfClass:UIViewController.class]) continue;
+    UIViewController *controller = current;
+    if (controller.isViewLoaded && [view isDescendantOfView:controller.view]) return YES;
+  }
+  return NO;
+}
+

package/ios/Sources/RnInteractionEventRegistration.swift

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 ScriptX
+import UIKit
+import EverframeKit
+
+/// Only committed refs acquire ownership; neither a configure nor a delayed callback renews it.
+@objc public final class RnInteractionEventRegistration: NSObject {
+    private final class Request {
+        let tag: NSNumber, generation: UInt64, lease: String, types: Set<String>
+        let resolve: (NSNumber) -> UIView?
+        weak var root: UIView?
+        weak var host: UIView?
+        var resolved = false
+        init(_ tag: NSNumber, _ generation: UInt64, _ lease: String, _ types: Set<String>, _ resolve: @escaping (NSNumber) -> UIView?) {
+            self.tag = tag; self.generation = generation; self.lease = lease; self.types = types; self.resolve = resolve
+        }
+    }
+    private static let instancesLock = NSLock()
+    private static let instances = NSHashTable<RnInteractionEventRegistration>.weakObjects()
+    private let dispatchRecord: (@escaping @MainActor () -> Void) -> Void
+    public override convenience init() {
+        self.init(dispatchRecord: { DispatchQueue.main.async(execute: $0) })
+    }
+    init(dispatchRecord: @escaping (@escaping @MainActor () -> Void) -> Void) {
+        self.dispatchRecord = dispatchRecord
+        super.init()
+        Self.instancesLock.lock(); Self.instances.add(self); Self.instancesLock.unlock()
+    }
+    @MainActor @objc public static func invalidateView(_ view: UIView) {
+        instancesLock.lock(); let owners = instances.allObjects; instancesLock.unlock()
+        for owner in owners {
+            owner.lock.lock(); defer { owner.lock.unlock() }
+            let matches = owner.requests.filter { $0.value.root === view || (!$0.value.resolved && $0.value.tag.intValue == view.tag) }
+            for (id, request) in matches {
+                InteractionEvents.cancelRegistration(id: owner.key(id), generation: request.generation)
+                owner.requests.removeValue(forKey: id)
+            }
+        }
+    }
+    private let lock = NSRecursiveLock()
+    private let runtime = InteractionEvents.openRuntime()
+    private var requests: [String: Request] = [:]
+    private struct PendingRecord {
+        let item: PreparedInteraction
+        let id: String
+        let generation: UInt64
+    }
+    private var records: [PendingRecord] = []
+    private var recordDrainScheduled = false
+    private var closed = false
+    @objc public var active: Bool { lock.lock(); defer { lock.unlock() }; return !closed && InteractionEvents.ownsRuntime(runtime) }
+    @objc public func lease() -> String { active ? InteractionEvents.lease() ?? "" : "" }
+    private func key(_ id: String) -> String { runtime + ":" + id }
+    private func integer(_ n: Double, _ max: Double) -> Bool { n.isFinite && n >= 0 && n <= max && n.rounded() == n }
+    private func validId(_ id: String) -> Bool { !id.isEmpty && id.utf16.count <= 128 && !id.unicodeScalars.contains { $0.value < 32 || $0.value == 127 } }
+    @objc public func setObserver(_ tag: Double, id: String, generation: Double, lease token: String, optionsJson: String,
+                                 resolve: @escaping (NSNumber) -> UIView?, host: @escaping (UIView) -> UIView?) -> Bool {
+        lock.lock(); defer { lock.unlock() }
+        guard active, validId(id), tag > 0, integer(tag, Double(Int32.max)), integer(generation, 9_007_199_254_740_990),
+              !token.isEmpty, token == lease(), optionsJson.utf8.count <= 8192,
+              let data = optionsJson.data(using: .utf8), let options = (try? JSONSerialization.jsonObject(with: data)) as? [String: Any],
+              let list = options["helperTypes"] as? [String], list.count <= 3, Set(list).isSubset(of: ["text_edit", "control_change", "scroll"]) else { return false }
+        requests = requests.filter { $0.value.lease == token }
+        guard requests.count < 4096 || requests[id] != nil,
+              InteractionEvents.beginRegistration(id: key(id), generation: UInt64(generation), lease: token, optionsJson: optionsJson) else { return false }
+        // JS callbacks cannot prove the native host was safe when observed.
+        // Keep metadata and lifetime tracking without suppressing native capture,
+        // including for older JS callers that still declare helper ownership.
+        let types: Set<String> = []
+        let request = Request(NSNumber(value: tag), UInt64(generation), token, types, resolve)
+        requests[id] = request; enqueue(id, request, host: host)
+        return true
+    }
+    private func enqueue(_ id: String, _ request: Request, host: @escaping (UIView) -> UIView?, attempt: Int = 0) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.lock.lock(); defer { self.lock.unlock() }
+            guard self.active, request.lease == self.lease(), self.requests[id] === request, !request.resolved else { return }
+            guard let root = request.resolve(request.tag), root.window != nil, root.tag == request.tag.intValue else {
+                if attempt < 8 {
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.016 * pow(2, Double(attempt))) { [weak self] in
+                        self?.enqueue(id, request, host: host, attempt: attempt + 1)
+                    }
+                }
+                return
+            }
+            guard var view = host(root) else { return }
+            // Fabric ScrollView exposes its native host through this public getter;
+            // its accessibility element is the wrapper, unlike TextInput/Switch.
+            if view.responds(to: NSSelectorFromString("scrollView")),
+               let scroll = view.value(forKey: "scrollView") as? UIScrollView { view = scroll }
+            guard view === root || view.isDescendant(of: root) else { return }
+            request.root = root; request.host = view; request.resolved = true
+            _ = InteractionEvents.completeRegistration(view: view, id: self.key(id), generation: request.generation, lease: request.lease, types: request.types)
+        }
+    }
+    @objc public func clearObserver(_ id: String, generation: Double) -> Bool {
+        lock.lock(); defer { lock.unlock() }
+        guard active, validId(id), integer(generation, 9_007_199_254_740_991),
+              InteractionEvents.clearRegistration(id: key(id), generation: UInt64(generation)) else { return false }
+        requests.removeValue(forKey: id); return true
+    }
+    @objc public func record(_ token: String, id: String, generation: Double, eventJson: String) -> Bool {
+        lock.lock(); defer { lock.unlock() }
+        guard active, integer(generation, 9_007_199_254_740_991), id.isEmpty || validId(id),
+              let item = InteractionEvents.prepare(lease: token, id: id.isEmpty ? "" : key(id), generation: UInt64(generation), json: eventJson) else { return false }
+        // Coalescing/revocation can empty cells before main runs. Bound those
+        // cells too and keep only one scheduled callback for this mailbox.
+        if records.count == 64 { InteractionEvents.discardPrepared(records.removeFirst().item) }
+        records.append(PendingRecord(item: item, id: id, generation: UInt64(generation)))
+        if !recordDrainScheduled { recordDrainScheduled = true; scheduleRecordDrain() }
+        return true
+    }
+    private func scheduleRecordDrain() {
+        dispatchRecord { [weak self] in self?.drainRecords() }
+    }
+    @MainActor private func drainRecords() {
+        // Yield after a bounded batch even if producers keep refilling the mailbox.
+        for _ in 0..<64 {
+            lock.lock(); defer { lock.unlock() }
+            guard !records.isEmpty else { break }
+            let pending = records.removeFirst()
+            defer { InteractionEvents.discardPrepared(pending.item) }
+            guard active else { continue }
+            if !pending.id.isEmpty {
+                guard let request = requests[pending.id], request.generation == pending.generation,
+                      let root = request.root, request.resolve(request.tag) === root, root.window != nil,
+                      let host = request.host, host === root || host.isDescendant(of: root) else { continue }
+            }
+            _ = InteractionEvents.recordPrepared(pending.item)
+        }
+        lock.lock(); defer { lock.unlock() }
+        if records.isEmpty { recordDrainScheduled = false } else { scheduleRecordDrain() }
+    }
+    @objc public func close() {
+        lock.lock(); defer { lock.unlock() }
+        closed = true
+        records.forEach { InteractionEvents.discardPrepared($0.item) }; records.removeAll()
+        requests.removeAll(); InteractionEvents.closeRuntime(runtime)
+    }
+}

package/ios/Sources/RnInteractionTargetRegistration.swift

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 ScriptX
+import UIKit
+import EverframeKit
+
+/// Ref cleanup cancels ownership immediately; UIKit work is always queued on main.
+@objc public final class RnInteractionTargetRegistration: NSObject {
+    private final class Request {
+        let tag: NSNumber, generation: UInt64, annotation: [String: Any]
+        let resolve: (NSNumber) -> UIView?
+        weak var view: UIView?
+        var resolved = false
+        init(_ tag: NSNumber, _ generation: UInt64, _ annotation: [String: Any], _ resolve: @escaping (NSNumber) -> UIView?) {
+            self.tag=tag; self.generation=generation; self.annotation=annotation; self.resolve=resolve
+        }
+    }
+    private let lock=NSRecursiveLock()
+    private let namespace=UUID().uuidString + ":"
+    private var requests: [String: Request]=[:]
+    private var destroyed=false
+    private var removeAdapter: (() -> Void)?
+    private var removeOriginAdapter: (() -> Void)?
+
+    @objc public func installOriginAdapter(_ read: @escaping (UIView) -> Bool) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.lock.lock(); defer { self.lock.unlock() }
+            guard !self.destroyed else { return }
+            self.removeOriginAdapter = InteractionOriginViewAdapters.register(read)
+        }
+    }
+
+    @objc public func installAdapter(_ read: @escaping (UIView) -> NSDictionary?) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.lock.lock(); defer { self.lock.unlock() }
+            guard !self.destroyed else { return }
+            self.removeAdapter=InteractionTargetViewAdapters.register { view in
+                guard let fields=read(view) else { return nil }
+                let raw=fields["role"] as? String
+                let role: String?
+                switch raw {
+                case "imagebutton": role="button"
+                case "adjustable": role="slider"
+                case "search", "searchbox", "textbox": role="textfield"
+                case "heading": role="header"
+                case "img": role="image"
+                case "none", "": role=nil
+                default: role=raw
+                }
+                return InteractionTargetViewHints(testId: fields["testId"] as? String, role:role, name:fields["name"] as? String ?? "",
+                    actionable: (fields["actionable"] as? Bool ?? false) || (role.map { ["button","tab","link","switch","checkbox","radio","slider","menuitem","textfield"].contains($0) } ?? false))
+            }
+        }
+    }
+    private func integer(_ n: Double, _ maximum: Double) -> Bool { n.isFinite && n >= 0 && n <= maximum && n.rounded() == n }
+    @objc public func setTarget(_ tag: Double, registrationId id: String, generation: Double, annotation: [String: Any], resolve: @escaping (NSNumber) -> UIView?) -> Bool {
+        lock.lock(); defer { lock.unlock() }
+        guard !destroyed, tag > 0, integer(tag,Double(Int32.max)), integer(generation,9_007_199_254_740_990),
+              InteractionTargetRegistry.beginSet(registrationId:namespace+id,generation:UInt64(generation)) else { return false }
+        let request=Request(NSNumber(value:tag),UInt64(generation),annotation,resolve)
+        requests[id]=request; enqueue(id,request)
+        return true
+    }
+    private func enqueue(_ id: String, _ request: Request, attempt: Int = 0) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.lock.lock(); defer { self.lock.unlock() }
+            guard !self.destroyed, self.requests[id] === request else { return }
+            guard let view=request.resolve(request.tag), view.window != nil else {
+                // Fabric refs precede mounting. Bound retries, and re-check ownership
+                // before every lookup so cleanup cannot register a recycled host.
+                if !request.resolved, attempt < 8 {
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 0.016 * pow(2, Double(attempt))) { [weak self] in
+                        self?.enqueue(id, request, attempt: attempt + 1)
+                    }
+                }
+                return
+            }
+            guard !request.resolved || request.view === view else { return }
+            request.view=view; request.resolved=true
+            InteractionTargetRegistry.completeSet(view:view,registrationId:self.namespace+id,generation:request.generation,annotation:request.annotation)
+        }
+    }
+    @objc public func clearTarget(_ id: String, generation: Double) -> Bool {
+        lock.lock(); defer { lock.unlock() }
+        guard !destroyed, integer(generation,9_007_199_254_740_991) else { return false }
+        if requests[id].map({ UInt64(generation) > $0.generation }) ?? true { requests.removeValue(forKey:id) }
+        InteractionTargetRegistry.clear(registrationId:namespace+id,generation:UInt64(generation))
+        return true
+    }
+    @objc public func onStarted() {
+        lock.lock(); defer { lock.unlock() }
+        guard !destroyed else { return }
+        for (id, request) in requests {
+            if InteractionTargetRegistry.beginSet(registrationId:namespace+id,generation:request.generation) { enqueue(id,request) }
+        }
+    }
+    @objc public func close() {
+        lock.lock(); defer { lock.unlock() }
+        destroyed=true
+        for (id, request) in requests { InteractionTargetRegistry.clear(registrationId:namespace+id,generation:request.generation+1) }
+        requests.removeAll()
+        DispatchQueue.main.async { [self] in removeAdapter?(); removeAdapter=nil; removeOriginAdapter?(); removeOriginAdapter=nil }
+    }
+    @MainActor @objc public static func invalidateView(_ view: UIView) { InteractionTargetRegistry.invalidate(view:view) }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everframe/react-native",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "description": "React Native SDK for Everframe — AI-ready in-app bug reporting, bridging the native iOS and Android reporter to your RN app. Supports phone, Apple TV, and Android TV.",
   "author": {
     "name": "Scriptx, UAB",
@@ -100,7 +100,7 @@
   "dependencies": {
     "bippy": "^0.5.39",
     "zod": "^4.3.0",
-    "@everframe/react": "^1.2.1"
+    "@everframe/react": "^1.4.0"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.0",
@@ -108,12 +108,13 @@
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
     "jsdom": "^29.1.1",
-    "react-dom": "^19.0.0",
     "publint": "^0.3.0",
+    "react-dom": "^19.0.0",
+    "react-native-url-polyfill": "4.0.0",
     "tsup": "^8.0.0",
     "vitest": "^4.0.0",
-    "@everframe/sdk-core": "0.6.0",
-    "@everframe/protocol": "0.7.0"
+    "@everframe/protocol": "0.9.0",
+    "@everframe/sdk-core": "0.6.1"
   },
   "codegenConfig": {
     "name": "EverframeSpec",