@everframe/react-native 1.2.1 → 1.4.0

package/android/src/main/java/dev/everframe/rn/RnInteractionEventRegistration.kt

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 ScriptX
+package dev.everframe.rn
+
+import android.view.View
+import dev.everframe.capture.InteractionEvents
+import dev.everframe.capture.PreparedInteraction
+import java.lang.ref.WeakReference
+import kotlinx.serialization.json.*
+
+/** Queued work owns the original lease. A new runtime cannot renew old refs or callbacks. */
+internal class RnInteractionEventRegistration(
+    private val resolve: (Int) -> View?,
+    private val dispatch: (() -> Unit) -> Unit,
+) : AutoCloseable {
+    private class Request(val tag: Int, val generation: Long, val lease: String, val types: Set<String>) {
+        var view: WeakReference<View>? = null
+        var resolved = false
+        var listener: View.OnAttachStateChangeListener? = null
+    }
+    val runtime = InteractionEvents.openRuntime()
+    private val namespace = "$runtime:"
+    private val requests = mutableMapOf<String, Request>()
+    private class PendingRecord(val item: PreparedInteraction, val id: String, val generation: Long)
+    private val records = ArrayDeque<PendingRecord>()
+    private var recordDrainScheduled = false
+    @Volatile private var closed = false
+    fun active(): Boolean = !closed && InteractionEvents.ownsRuntime(runtime)
+    fun lease(): String = if (active()) InteractionEvents.lease() ?: "" else ""
+    private fun integer(value: Double, max: Double) = value.isFinite() && value >= 0 && value <= max && value == value.toLong().toDouble()
+    private fun validId(id: String) = id.isNotEmpty() && id.length <= 128 && id.none { it.code < 32 || it.code == 127 }
+    @Synchronized fun set(tag: Double, id: String, generation: Double, lease: String, json: String): Boolean {
+        if (!active() || !validId(id) || tag <= 0 || !integer(tag,Int.MAX_VALUE.toDouble()) || !integer(generation,9007199254740990.0) || lease.isEmpty() || lease != lease()) return false
+        if (json.toByteArray(Charsets.UTF_8).size > 8192) return false
+        val options = runCatching { Json.parseToJsonElement(json) as? JsonObject }.getOrNull() ?: return false
+        val list = options["helperTypes"] as? JsonArray ?: return false
+        if (list.size > 3) return false
+        val types = list.map { (it as? JsonPrimitive)?.takeIf { it.isString }?.content ?: return false }.toSet()
+        if (!setOf("text_edit","control_change","scroll").containsAll(types)) return false
+        // JS callbacks have no immutable native privacy proof at observation.
+        // Keep annotations while leaving all native automatic observation active.
+        requests.filterValues { it.lease != lease }.values.forEach(::detachListener)
+        requests.entries.removeAll { it.value.lease != lease }
+        if (requests.size >= 4096 && !requests.containsKey(id)) return false
+        if (!InteractionEvents.beginRegistration(namespace+id,generation.toLong(),lease,json)) return false
+        val request = Request(tag.toInt(),generation.toLong(),lease,emptySet())
+        requests.put(id,request)?.let(::detachListener); enqueue(id,request)
+        return true
+    }
+    private fun enqueue(id: String, request: Request) {
+        dispatch {
+            synchronized(this) {
+                if (!active() || request.lease != lease() || requests[id] !== request || request.resolved) return@dispatch
+                val view = runCatching { resolve(request.tag) }.getOrNull() ?: return@dispatch
+                if (!view.isAttachedToWindow || view.id != request.tag) return@dispatch
+                request.view = WeakReference(view); request.resolved = true
+                if (InteractionEvents.completeRegistration(view,namespace+id,request.generation,request.lease,request.types)) {
+                    val owner = WeakReference(this)
+                    val nativeId = namespace+id
+                    val listener = object : View.OnAttachStateChangeListener {
+                        override fun onViewAttachedToWindow(view: View) = Unit
+                        override fun onViewDetachedFromWindow(view: View) {
+                            view.removeOnAttachStateChangeListener(this)
+                            InteractionEvents.cancelRegistration(nativeId,request.generation)
+                            owner.get()?.let { bridge -> synchronized(bridge) { if (bridge.requests[id] === request) bridge.requests.remove(id) } }
+                        }
+                    }
+                    request.listener = listener; view.addOnAttachStateChangeListener(listener)
+                }
+            }
+        }
+    }
+    private fun detachListener(request: Request) {
+        dispatch { request.listener?.let { request.view?.get()?.removeOnAttachStateChangeListener(it) }; request.listener = null }
+    }
+    @Synchronized fun onMount() {
+        if (!active()) return
+        requests.filterValues { it.lease != lease() }.values.forEach(::detachListener)
+        requests.entries.removeAll { it.value.lease != lease() }
+        requests.filterValues { !it.resolved }.forEach { (id,request) -> enqueue(id,request) }
+    }
+    @Synchronized fun clear(id: String, generation: Double): Boolean {
+        if (!active() || !validId(id) || !integer(generation,9007199254740991.0)) return false
+        if (!InteractionEvents.clearRegistration(namespace+id,generation.toLong())) return false
+        requests.remove(id)?.let(::detachListener); return true
+    }
+    @Synchronized fun record(lease: String, id: String, generation: Double, json: String): Boolean {
+        if (!active() || !integer(generation,9007199254740991.0) || (id.isNotEmpty() && !validId(id))) return false
+        val prepared = InteractionEvents.prepare(lease,if (id.isEmpty()) "" else namespace+id,generation.toLong(),json) ?: return false
+        // Native coalescing/revocation can empty a prepared cell before main runs.
+        // Bound those cells too, and enqueue only one callback for the mailbox.
+        if (records.size == 64) InteractionEvents.discardPrepared(records.removeFirst().item)
+        records.addLast(PendingRecord(prepared,id,generation.toLong()))
+        if (!recordDrainScheduled) { recordDrainScheduled = true; scheduleRecordDrain() }
+        return true
+    }
+    private fun scheduleRecordDrain() {
+        val owner = WeakReference(this)
+        dispatch { owner.get()?.drainRecords() }
+    }
+    private fun drainRecords() {
+        // Yield after a bounded batch even if producers keep refilling the mailbox.
+        repeat(64) {
+            synchronized(this) {
+                if (records.isEmpty()) return@repeat
+                val pending = records.removeFirst()
+                try {
+                    if (!active()) return@repeat
+                    if (pending.id.isNotEmpty()) {
+                        val request = requests[pending.id] ?: return@repeat
+                        val view = request.view?.get() ?: return@repeat
+                        if (request.generation != pending.generation || resolve(request.tag) !== view) return@repeat
+                    }
+                    InteractionEvents.recordPrepared(pending.item)
+                } finally { InteractionEvents.discardPrepared(pending.item) }
+            }
+        }
+        synchronized(this) {
+            if (records.isEmpty()) recordDrainScheduled = false else scheduleRecordDrain()
+        }
+    }
+    @Synchronized override fun close() {
+        closed = true
+        records.forEach { InteractionEvents.discardPrepared(it.item) }; records.clear()
+        requests.values.forEach(::detachListener); requests.clear(); InteractionEvents.closeRuntime(runtime)
+    }
+}

package/android/src/main/java/dev/everframe/rn/RnInteractionTargetAdapter.kt

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 ScriptX
+package dev.everframe.rn
+
+import android.view.View
+import com.facebook.react.ReactRootView
+import com.facebook.react.uimanager.ReactAccessibilityDelegate.AccessibilityRole
+import com.facebook.react.uimanager.ReactAccessibilityDelegate.Role
+import dev.everframe.capture.InteractionTargetViewAdapter
+import dev.everframe.capture.InteractionTargetViewHints
+import java.util.Locale
+
+internal object RnInteractionTargetAdapter : InteractionTargetViewAdapter {
+    override fun describe(view: View): InteractionTargetViewHints? {
+        val testId = view.getTag(com.facebook.react.R.id.react_test_id) as? String
+        val rawRole = ((view.getTag(com.facebook.react.R.id.role) as? Role)?.name
+            ?: (view.getTag(com.facebook.react.R.id.accessibility_role) as? AccessibilityRole)?.name)?.lowercase(Locale.ROOT)
+        val role = when (rawRole) {
+            "imagebutton" -> "button"
+            "adjustable" -> "slider"
+            "edittext", "search", "searchbox", "textbox" -> "textfield"
+            "heading" -> "header"
+            "img" -> "image"
+            "none", null -> null
+            else -> rawRole
+        }
+        return InteractionTargetViewHints(testId = testId, role = role,
+            // ReactSurfaceView (Fabric) also extends ReactRootView. The module
+            // identity is assigned by the framework, independent of rendered labels.
+            devtools = view is ReactRootView && runCatching { view.jsModuleName in setOf("LogBox", "DevMenu") }.getOrDefault(false),
+            actionable = role in setOf("button", "tab", "link", "switch", "checkbox", "radio", "slider", "menuitem", "textfield"))
+    }
+}

package/android/src/main/java/dev/everframe/rn/RnInteractionTargetRegistration.kt

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: 2026 ScriptX
+package dev.everframe.rn
+
+import android.view.View
+import dev.everframe.capture.InteractionTargetRegistry
+import java.lang.ref.WeakReference
+import java.util.UUID
+
+/** Synchronous ownership cancellation, UI-only host resolution. Never waits for the UI thread. */
+internal class RnInteractionTargetRegistration(
+    private val resolve: (Int) -> View?,
+    private val dispatch: (() -> Unit) -> Unit,
+) : AutoCloseable {
+    private class Request(val tag: Int, val generation: Long, val annotation: Map<String, Any?>) {
+        var view: WeakReference<View>? = null
+    }
+    private val namespace = UUID.randomUUID().toString() + ":"
+    private val requests = mutableMapOf<String, Request>()
+    private var destroyed = false
+    private val pending = mutableMapOf<String, Request>()
+    private fun integer(value: Double, maximum: Double) = value.isFinite() && value >= 0 && value <= maximum && value == value.toLong().toDouble()
+
+    @Synchronized fun set(tag: Double, id: String, generation: Double, annotation: Map<String, Any?>): Boolean {
+        if (destroyed || tag <= 0 || !integer(tag, Int.MAX_VALUE.toDouble()) || !integer(generation, 9007199254740990.0)) return false
+        val key = namespace + id
+        if (!InteractionTargetRegistry.beginSet(key, generation.toLong())) return false
+        val request = Request(tag.toInt(), generation.toLong(), annotation)
+        requests[id] = request
+        pending[id] = request
+        enqueue(id, request)
+        return true
+    }
+    private fun enqueue(id: String, request: Request) {
+        try { dispatch {
+            synchronized(this) {
+                if (!destroyed && requests[id] === request) {
+                    val view = runCatching { resolve(request.tag) }.getOrNull()
+                    // A resolved host cannot migrate to a replacement using the same numeric tag.
+                    if (view != null && (request.view == null || request.view?.get() === view)) {
+                        pending.remove(id)
+                        request.view = WeakReference(view)
+                        InteractionTargetRegistry.completeSet(view, namespace + id, request.generation, request.annotation)
+                    }
+                }
+            }
+        } } catch (_: Throwable) { InteractionTargetRegistry.clear(namespace + id, request.generation + 1) }
+    }
+    /** Fabric can deliver the ref before the native mount. Retry only live unresolved owners. */
+    @Synchronized fun onMount() {
+        if (!destroyed && pending.isNotEmpty()) pending.toList().forEach { (id, request) -> enqueue(id, request) }
+    }
+
+    @Synchronized fun clear(id: String, generation: Double): Boolean {
+        if (destroyed || !integer(generation, 9007199254740991.0)) return false
+        val current = requests[id]
+        if (current == null || generation > current.generation) { requests.remove(id); pending.remove(id) }
+        InteractionTargetRegistry.clear(namespace + id, generation.toLong())
+        return true
+    }
+    /** Provider configure may run after child ref attachment. Core start clears its registry. */
+    @Synchronized fun onStarted() {
+        if (!destroyed) requests.forEach { (id, request) ->
+            if (InteractionTargetRegistry.beginSet(namespace + id, request.generation)) { pending[id] = request; enqueue(id, request) }
+        }
+    }
+    @Synchronized override fun close() {
+        destroyed = true
+        requests.forEach { (id, request) -> InteractionTargetRegistry.clear(namespace + id, request.generation + 1) }
+        requests.clear(); pending.clear()
+    }
+}

package/dist/NativeEverframe.d.ts

@@ -23,6 +23,8 @@ type Rect = {
  * Rich variants (e.g., callbacks, function refs) MUST stay on the JS side.
  */
 type ConfigOpts = {
+    /** Bounded local interaction policy; native validation remains authoritative. */
+    interactionsJson?: string;
     sdkKey?: string;
     sdkVersion?: string;
     /**
@@ -148,6 +150,9 @@ type ConfigOpts = {
      * sends it (the config's `debugBuild`, else `__DEV__`). Absent means the native SDK decides for itself.
      */
     debugBuild?: boolean;
+    /** Loaded Hermes identity for ordinary reports, independent of release health. */
+    jsBundleBuildId?: string;
+    jsBundleName?: string;
     /**
      * Native foreground monitoring (release health). The JS facade always sends this flag: `true` with a
      * validated loaded bundle, or `false` to revoke monitoring. A bridge that finds it missing treats it as
@@ -192,6 +197,16 @@ interface Spec extends TurboModule {
      * Typed `UnsafeObject` at codegen boundary; facade casts to `ReporterResult`.
      */
     openReporter(): Promise<UnsafeObject>;
+    openReporterWithTrigger(trigger: string): Promise<UnsafeObject>;
+    markReporterOpened(trigger: string): Promise<void>;
+    markReporterClosed(): Promise<void>;
+    setInteractionTarget(viewTag: number, registrationId: string, generation: number, annotation: UnsafeObject): boolean;
+    clearInteractionTarget(registrationId: string, generation: number): boolean;
+    /** Revocable semantic observation ownership; unrelated to replay controls. */
+    getInteractionLease(): string;
+    setInteractionObserver(viewTag: number, id: string, generation: number, lease: string, optionsJson: string): boolean;
+    clearInteractionObserver(id: string, generation: number): boolean;
+    recordInteraction(lease: string, id: string, generation: number, eventJson: string): boolean;
     registerSensitiveRect(viewTag: number, rect: Rect): void;
     /**
      * Set host-supplied free-form metadata for the next report. Single opaque
@@ -342,6 +357,9 @@ interface Spec extends TurboModule {
      * credential. It groups reports in the dashboard and does nothing else.
      */
     setUser(user?: UnsafeObject): void;
+    /** Synchronous acknowledgement preserves setState → fatal capture ordering. */
+    setStateSync(key: string, valueJson: string): boolean;
+    clearStateSync(key: string): boolean;
 }
 declare const _default: Spec;
 

package/dist/chunk-FZHLCD3Z.js

@@ -0,0 +1 @@
+import{a as i,c as s,e as a}from"./chunk-UN3Q4UGZ.js";import{a as t}from"./chunk-XUSV3KOD.js";var n=class extends Error{static{t(this,"EverframeNotMountedError")}name="EverframeNotMountedError";constructor(o){super(o??"EverframeProvider is not mounted; wrap your app root.")}},c="EVERFRAME_REPORTER_DISABLED",p=class extends Error{static{t(this,"EverframeReporterDisabledError")}name="EverframeReporterDisabledError";constructor(o){super(o??"The Everframe reporter is disabled in this session (reporter.disabled).")}};function d(e){return e==="button"||e==="shake"||e==="menu"||e==="companion"}t(d,"isReporterTrigger");var r=null,u={};function R(){return u}t(R,"__getContextEpoch");function f(){try{return r?.getPromiseRejectionStatus()??a("not-mounted","no-mount")}catch{return a("install-failed","hook-install")}}t(f,"getPromiseRejectionStatus");function S(e){r=e,u={}}t(S,"__setCurrentContext");function y(){return r}t(y,"__getCurrentContext");function C(e){let o=r;return o?o.open(e):Promise.reject(new n("EverframeProvider not mounted; wrap your root with <EverframeProvider>."))}t(C,"open");function k(e){r?.setExtra(e)}t(k,"setExtra");function b(e){r?.addBreadcrumb(e)}t(b,"addBreadcrumb");function P(e,o){o!==void 0?r?.recordScreen(e,o):r?.recordScreen(e)}t(P,"recordScreen");function O(e){r?.setUser(e)}t(O,"setUser");function w(e,o){r?.captureException(e,o)}t(w,"captureException");function h(){try{return r?.getErrorCaptureStatus()??s("not-mounted","no-mount")}catch{return s("not-mounted","no-mount")}}t(h,"getErrorCaptureStatus");function j(){let e=r;try{let o=e?.getReportDeliveryStatus();return e===r&&o?o:i("not-mounted","no-mount")}catch{return i("unavailable","native-call-failed")}}t(j,"getReportDeliveryStatus");function _(e,o){r?.setState(e,o)}t(_,"setState");function D(e){r?.clearState(e)}t(D,"clearState");async function T(e){await r?.markReporterOpened(e)}t(T,"markReporterOpened");async function V(){await r?.markReporterClosed()}t(V,"markReporterClosed");export{n as a,c as b,p as c,d,R as e,f,S as g,y as h,C as i,k as j,b as k,P as l,O as m,w as n,h as o,j as p,_ as q,D as r,T as s,V as t};