detox 20.43.0 → 20.44.0-smoke.1

package/Detox-android/com/wix/detox/20.44.0-smoke.1/detox-20.44.0-smoke.1-sources.jar.md5

@@ -0,0 +1 @@
+bdf9863f8c4afcf4541218e9b3bed4a3

package/Detox-android/com/wix/detox/20.44.0-smoke.1/detox-20.44.0-smoke.1-sources.jar.sha1

@@ -0,0 +1 @@
+760a64eb6cdd8807b45b398d53de460c48df99a5

package/Detox-android/com/wix/detox/20.44.0-smoke.1/detox-20.44.0-smoke.1-sources.jar.sha256

@@ -0,0 +1 @@
+8e42be451e2bd115b75216749965d28317bddb694a2e880adab3abb709ba1d08

package/Detox-android/com/wix/detox/20.44.0-smoke.1/detox-20.44.0-smoke.1-sources.jar.sha512

@@ -0,0 +1 @@
+5cb65dc5c27e0964f4fd77c1cb638cd071b43db67100cae210c0205ea2e87b3268bfb8543c06a8baf10aa748d4eb49302db99390464b639bc4e9c8a2eeabd278

package/Detox-android/com/wix/detox/20.44.0-smoke.1/detox-20.44.0-smoke.1.aar.md5

@@ -0,0 +1 @@
+1a39cefde2e8dde2ca54d70b0c5e5b0d

package/Detox-android/com/wix/detox/20.44.0-smoke.1/detox-20.44.0-smoke.1.aar.sha1

@@ -0,0 +1 @@
+39e35796a4308c0a15457b1613b96b090f721432

package/Detox-android/com/wix/detox/20.44.0-smoke.1/detox-20.44.0-smoke.1.aar.sha256

@@ -0,0 +1 @@
+76090af6a690fc00138ac3c3a307fe3cc49dfde32789bbc2d8066fa53e67805b

package/Detox-android/com/wix/detox/20.44.0-smoke.1/detox-20.44.0-smoke.1.aar.sha512

@@ -0,0 +1 @@
+12b0c9b12325ad848ba52cdbbea6a37d837b341d5f98d6c4c34c45f357cebbfc767466df76479ebde2f1546cdc2211cfe02a3bf383371ac24b1e3de43df568b5

package/Detox-android/com/wix/detox/{20.43.0/detox-20.43.0.pom → 20.44.0-smoke.1/detox-20.44.0-smoke.1.pom}

@@ -3,7 +3,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.wix</groupId>
   <artifactId>detox</artifactId>
-  <version>20.43.0</version>
+  <version>20.44.0-smoke.1</version>
   <packaging>aar</packaging>
   <name>Detox</name>
   <description>Gray box end-to-end testing and automation library for mobile apps</description>

package/Detox-android/com/wix/detox/20.44.0-smoke.1/detox-20.44.0-smoke.1.pom.md5

@@ -0,0 +1 @@
+aae3ffc3cd9babca3385c2de23ca2be0

package/Detox-android/com/wix/detox/20.44.0-smoke.1/detox-20.44.0-smoke.1.pom.sha1

@@ -0,0 +1 @@
+b6de9c93a0a4fdc91a1e1335dc19a90d6fe592bd

package/Detox-android/com/wix/detox/20.44.0-smoke.1/detox-20.44.0-smoke.1.pom.sha256

@@ -0,0 +1 @@
+305c59339a78c67c7fa2b6ab908c7f455d6faeb039827af94e5426238d4f464e

package/Detox-android/com/wix/detox/20.44.0-smoke.1/detox-20.44.0-smoke.1.pom.sha512

@@ -0,0 +1 @@
+3e6d2c931c52d22342ae2c2cbc0cbd4c38c74e3240a48d95cfe69a1561eb76337dbfdd4dd2753414c19f02b42e16c1fa8f2965efe9fffafce9122cd798eecf22

package/Detox-android/com/wix/detox/maven-metadata.xml

@@ -3,11 +3,11 @@
   <groupId>com.wix</groupId>
   <artifactId>detox</artifactId>
   <versioning>
-    <latest>20.43.0</latest>
-    <release>20.43.0</release>
+    <latest>20.44.0-smoke.1</latest>
+    <release>20.44.0-smoke.1</release>
     <versions>
-      <version>20.43.0</version>
+      <version>20.44.0-smoke.1</version>
     </versions>
-    <lastUpdated>20251005174840</lastUpdated>
+    <lastUpdated>20251009104839</lastUpdated>
   </versioning>
 </metadata>

package/Detox-android/com/wix/detox/maven-metadata.xml.md5

@@ -1 +1 @@
-886f630a5f15d5956dc1ee88ddc28a93
+4baad9ede6680e5d2b46f1246a48c8f9

package/Detox-android/com/wix/detox/maven-metadata.xml.sha1

@@ -1 +1 @@
-9827172d9c41c9c0b8aebcafed3c6aa9fdee38f3
+b07f36a5c0ae07b6a7961b318ca15b8acc44d602

package/Detox-android/com/wix/detox/maven-metadata.xml.sha256

@@ -1 +1 @@
-f72c0489fa076f46a4b8f1f067a2d61d92d8b1e6b803abd1a7497197da9bdf23
+a95b41be51ad53267864aae6fc777db00648abe236c7bdbd46c645543e9c052f

package/Detox-android/com/wix/detox/maven-metadata.xml.sha512

@@ -1 +1 @@
-cbaade5e87589c6fb562c9434649cf4097519e46df99f89d5f18169b1bdc623afbced20c9f2631110773d7c35e2751358669f23b7aef6949feb01b035468686e
+03f466d7a8a4a9f3a5b82b78cc9fcfc0020dd9bb7e3c7d821096887eb241118db40ce09f2f4912a6de05bd2b4c4d75ad48133665e37f68c37bae4a3b227d08ca

package/android/detox/src/full/java/com/wix/detox/adapters/server/DetoxActionHandlers.kt

@@ -69,11 +69,17 @@ class InvokeActionHandler @JvmOverloads constructor(
         val viewHierarchy = if (error is DetoxExceptionWithHierarchy) {
             error.xmlHierarchy
         } else {
-            null
+            generateFallbackViewHierarchy()
         }
 
         return mapOf<String, Any?>("details" to "${errorMessage}\n", "viewHierarchy" to viewHierarchy)
     }
+
+    private fun generateFallbackViewHierarchy() = try {
+        ViewHierarchyGenerator.generateXml(shouldInjectTestIds = false)
+    } catch (e: Exception) {
+        null
+    }
 }
 
 class CleanupActionHandler(

package/android/detox/src/full/java/com/wix/detox/espresso/hierarchy/ViewHierarchyGenerator.kt

@@ -8,6 +8,7 @@ import android.webkit.WebView
 import android.widget.TextView
 import com.wix.detox.espresso.DeviceDisplay
 import com.wix.detox.reactnative.ui.getAccessibilityLabel
+import com.wix.detox.inquiry.ViewLifecycleRegistry
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.suspendCancellableCoroutine
@@ -162,6 +163,9 @@ object ViewHierarchyGenerator {
             "label" to (view.getAccessibilityLabel()?.toString() ?: "")
         )
 
+        // Add lifecycle information from ViewLifecycleRegistry
+        addLifecycleAttributes(view, attributes)
+
         val location = IntArray(2).apply { view.getLocationInWindow(this) }
         attributes["x"] = location[0].toString()
         attributes["y"] = location[1].toString()
@@ -200,4 +204,64 @@ object ViewHierarchyGenerator {
         View.GONE -> "gone"
         else -> "unknown"
     }
+
+    /**
+     * Add lifecycle attributes to the view attributes map.
+     * This includes information about recent animations, updates, and mounts.
+     */
+    private fun addLifecycleAttributes(view: View, attributes: MutableMap<String, String>) {
+        try {
+            // Check if view was recently animated (within last 1.5 seconds)
+            if (ViewLifecycleRegistry.wasRecentlyAnimated(view, 1500)) {
+                attributes["recentlyAnimated"] = "true"
+
+                // Add animation count if available
+                val lifecycleInfo = ViewLifecycleRegistry.getLifecycleInfo(view)
+                lifecycleInfo?.let { info ->
+                    attributes["animationCount"] = info.animationCount.toString()
+                    attributes["lastAnimateTime"] = info.lastAnimateTime.toString()
+                }
+            }
+
+            // Check if view was recently updated (within last 1 second)
+            if (ViewLifecycleRegistry.wasRecentlyUpdated(view, 1000)) {
+                attributes["recentlyUpdated"] = "true"
+
+                val lifecycleInfo = ViewLifecycleRegistry.getLifecycleInfo(view)
+                lifecycleInfo?.let { info ->
+                    attributes["updateCount"] = info.updateCount.toString()
+                    attributes["lastUpdateTime"] = info.lastUpdateTime.toString()
+                }
+            }
+
+            // Check if view was recently mounted (within last 5 seconds)
+            if (ViewLifecycleRegistry.wasRecentlyMounted(view, 5000)) {
+                attributes["recentlyMounted"] = "true"
+
+                val lifecycleInfo = ViewLifecycleRegistry.getLifecycleInfo(view)
+                lifecycleInfo?.let { info ->
+                    attributes["mountTime"] = info.mountTime.toString()
+                }
+            }
+
+            // Check for problematic animations
+            if (ViewLifecycleRegistry.hasCustomEvent(view, "problematic_animation", 2000)) {
+                attributes["problematicAnimation"] = "true"
+            }
+
+            // Add any other custom events
+            val lifecycleInfo = ViewLifecycleRegistry.getLifecycleInfo(view)
+            lifecycleInfo?.let { info ->
+                if (info.customEvents.isNotEmpty()) {
+                    val customEvents = info.customEvents.keys.joinToString(",")
+                    attributes["customEvents"] = customEvents
+                }
+            }
+
+        } catch (e: Exception) {
+            // Silently ignore errors to avoid breaking the hierarchy generation
+            // Log at debug level for debugging
+            android.util.Log.d("ViewHierarchyGenerator", "Failed to add lifecycle attributes", e)
+        }
+    }
 }

package/android/detox/src/full/java/com/wix/detox/inquiry/DetoxAnimationTracker.kt

@@ -0,0 +1,70 @@
+package com.wix.detox.inquiry
+
+import android.util.Log
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.fabric.FabricUIManager
+import com.facebook.react.uimanager.UIManagerHelper
+// import com.facebook.react.uimanager.UIManagerType
+
+/**
+ * Main entry point for Detox animation tracking in Fabric.
+ * This provides a simple API to initialize and use the animation tracking system.
+ */
+object DetoxAnimationTracker {
+    private const val LOG_TAG = "DetoxAnimationTracker"
+    private var isInitialized = false
+
+    /**
+     * Initialize the animation tracking system.
+     * This should be called once when Detox starts up.
+     */
+    fun initialize(reactContext: ReactContext) {
+        if (isInitialized) {
+            Log.d(LOG_TAG, "DetoxAnimationTracker already initialized")
+            return
+        }
+
+        try {
+            // Initialize the Fabric integration
+            DetoxFabricIntegration.initialize(reactContext)
+            isInitialized = true
+            Log.i(LOG_TAG, "DetoxAnimationTracker initialized successfully")
+
+        } catch (e: Exception) {
+            Log.e(LOG_TAG, "Failed to initialize DetoxAnimationTracker", e)
+        }
+    }
+
+    /**
+     * Get the current animation statistics
+     */
+    fun getAnimationStats(): Map<String, Any> {
+        return ViewLifecycleRegistry.getStats()
+    }
+
+    /**
+     * Get all recently animated views
+     */
+    fun getRecentlyAnimatedViews(): List<android.view.View> {
+        return ViewLifecycleRegistry.getRecentlyAnimatedViews()
+    }
+
+    /**
+     * Check if a specific view was recently animated
+     */
+    fun wasRecentlyAnimated(view: android.view.View): Boolean {
+        return ViewLifecycleRegistry.wasRecentlyAnimated(view)
+    }
+
+    /**
+     * Clear all animation tracking data
+     */
+    fun clear() {
+        ViewLifecycleRegistry.clear()
+    }
+
+    /**
+     * Check if the tracker is initialized
+     */
+    fun isInitialized(): Boolean = isInitialized
+}

package/android/detox/src/full/java/com/wix/detox/inquiry/DetoxFabricAnimationHook.kt

@@ -0,0 +1,83 @@
+package com.wix.detox.inquiry
+
+import android.util.Log
+import android.view.View
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.fabric.FabricUIManager
+import com.wix.detox.inquiry.ViewLifecycleRegistry.markAnimated
+import com.wix.detox.inquiry.ViewLifecycleRegistry.markMounted
+import com.wix.detox.inquiry.ViewLifecycleRegistry.markUpdated
+
+/**
+ * Hook into React Native's Fabric new architecture to track animated views.
+ * This provides precise tracking by intercepting the exact points where animated
+ * properties are applied to views in Fabric.
+ */
+object DetoxFabricAnimationHook {
+    private const val LOG_TAG = "DetoxFabricHook"
+
+    /**
+     * Hook into FabricUIManager.synchronouslyUpdateViewOnUIThread to track animated updates.
+     * This marks views as animated whenever there's any animation activity, giving lots of false positives.
+     */
+    fun hookSynchronouslyUpdateViewOnUIThread(
+        reactTag: Int,
+        props: ReadableMap?,
+        fabricUIManager: FabricUIManager
+    ) {
+        try {
+            // Get the actual Android View
+            val androidView = fabricUIManager.resolveView(reactTag)
+            if (androidView == null) {
+                Log.d(LOG_TAG, "View not found for tag: $reactTag")
+                return
+            }
+
+            markAnimated(androidView)
+        } catch (e: Exception) {
+            Log.w(LOG_TAG, "Failed to hook animated view update", e)
+        }
+    }
+
+    /**
+     * Hook into view mount operations to track when views are created.
+     */
+    fun hookViewMount(
+        reactTag: Int,
+        fabricUIManager: FabricUIManager
+    ) {
+        try {
+            val androidView = fabricUIManager.resolveView(reactTag)
+            if (androidView != null) {
+                Log.d(LOG_TAG, "View mounted with tag: $reactTag")
+                markMounted(androidView)
+            }
+        } catch (e: Exception) {
+            Log.w(LOG_TAG, "Failed to hook view mount", e)
+        }
+    }
+
+
+    /**
+     * Get view coordinates for highlighting
+     */
+    fun getViewCoordinates(view: View): IntArray {
+        val coords = intArrayOf(0, 0, 0, 0)
+        try {
+            view.getLocationOnScreen(coords)
+            coords[2] = view.width
+            coords[3] = view.height
+        } catch (e: Exception) {
+            Log.w(LOG_TAG, "Failed to get view coordinates", e)
+        }
+        return coords
+    }
+
+    /**
+     * Log current registry statistics
+     */
+    fun logRegistryStats() {
+        val stats = ViewLifecycleRegistry.getStats()
+        Log.i(LOG_TAG, "ViewLifecycleRegistry stats: $stats")
+    }
+}

package/android/detox/src/full/java/com/wix/detox/inquiry/DetoxFabricIntegration.kt

@@ -0,0 +1,99 @@
+package com.wix.detox.inquiry
+
+import android.util.Log
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.fabric.FabricUIManager
+import com.facebook.react.uimanager.UIManagerHelper
+// import com.facebook.react.uimanager.UIManagerType
+
+/**
+ * Integration point for Detox with React Native's Fabric architecture.
+ * This provides hooks into Fabric's animation system to track animated views.
+ */
+object DetoxFabricIntegration {
+    private const val LOG_TAG = "DetoxFabricIntegration"
+    private var isInitialized = false
+
+    /**
+     * Initialize the Fabric animation hooks.
+     * This should be called once when Detox starts up.
+     */
+    fun initialize(reactContext: ReactContext) {
+        if (isInitialized) {
+            Log.d(LOG_TAG, "DetoxFabricIntegration already initialized")
+            return
+        }
+
+        try {
+            // Get the FabricUIManager
+            val fabricUIManager = UIManagerHelper.getUIManager(reactContext, 1) as? FabricUIManager
+            if (fabricUIManager == null) {
+                Log.w(LOG_TAG, "FabricUIManager not available - Fabric animation tracking disabled")
+                return
+            }
+
+            // Hook into the FabricUIManager
+            hookFabricUIManager(fabricUIManager)
+            isInitialized = true
+            Log.i(LOG_TAG, "DetoxFabricIntegration initialized successfully")
+
+        } catch (e: Exception) {
+            Log.e(LOG_TAG, "Failed to initialize DetoxFabricIntegration", e)
+        }
+    }
+
+    /**
+     * Hook into FabricUIManager to track animated updates.
+     * This uses reflection to intercept synchronouslyUpdateViewOnUIThread calls.
+     */
+    private fun hookFabricUIManager(fabricUIManager: FabricUIManager) {
+        try {
+            // Create a wrapper that intercepts calls to synchronouslyUpdateViewOnUIThread
+            val originalMethod = FabricUIManager::class.java.getDeclaredMethod(
+                "synchronouslyUpdateViewOnUIThread",
+                Int::class.java,
+                com.facebook.react.bridge.ReadableMap::class.java
+            )
+
+            // Note: In a real implementation, you would use bytecode manipulation
+            // or AOP to intercept this method. For now, we'll provide a manual hook
+            // that can be called from the application code.
+
+            Log.d(LOG_TAG, "FabricUIManager hook prepared (manual integration required)")
+
+        } catch (e: Exception) {
+            Log.w(LOG_TAG, "Failed to hook FabricUIManager", e)
+        }
+    }
+
+    /**
+     * Manual hook for synchronouslyUpdateViewOnUIThread.
+     * This should be called from the application's FabricUIManager wrapper.
+     */
+    fun onSynchronouslyUpdateViewOnUIThread(
+        reactTag: Int,
+        props: com.facebook.react.bridge.ReadableMap?,
+        fabricUIManager: FabricUIManager
+    ) {
+        DetoxFabricAnimationHook.hookSynchronouslyUpdateViewOnUIThread(reactTag, props, fabricUIManager)
+    }
+
+    /**
+     * Manual hook for view mount operations.
+     */
+    fun onViewMount(reactTag: Int, fabricUIManager: FabricUIManager) {
+        DetoxFabricAnimationHook.hookViewMount(reactTag, fabricUIManager)
+    }
+
+    /**
+     * Check if the integration is initialized
+     */
+    fun isInitialized(): Boolean = isInitialized
+
+    /**
+     * Get current animation statistics
+     */
+    fun getAnimationStats(): Map<String, Any> {
+        return ViewLifecycleRegistry.getStats()
+    }
+}

package/android/detox/src/full/java/com/wix/detox/inquiry/DetoxFabricUIManagerWrapper.kt

@@ -0,0 +1,37 @@
+package com.wix.detox.inquiry
+
+import android.util.Log
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.fabric.FabricUIManager
+
+/**
+ * Wrapper for FabricUIManager that intercepts animation-related calls.
+ * This provides a clean way to hook into Fabric's animation system.
+ */
+class DetoxFabricUIManagerWrapper(
+    private val originalUIManager: FabricUIManager
+) {
+    private val LOG_TAG = "DetoxFabricUIManagerWrapper"
+
+    fun synchronouslyUpdateViewOnUIThread(reactTag: Int, props: ReadableMap?) {
+        try {
+            // Call the original method first (only if props is not null)
+            if (props != null) {
+                originalUIManager.synchronouslyUpdateViewOnUIThread(reactTag, props)
+            }
+
+            // Then hook our animation tracking
+            DetoxFabricAnimationHook.hookSynchronouslyUpdateViewOnUIThread(reactTag, props, originalUIManager)
+
+        } catch (e: Exception) {
+            Log.w(LOG_TAG, "Failed to process animated view update", e)
+            // Still call the original method to avoid breaking the app (only if props is not null)
+            if (props != null) {
+                originalUIManager.synchronouslyUpdateViewOnUIThread(reactTag, props)
+            }
+        }
+    }
+
+    // Delegate all other methods to the original UIManager
+    fun resolveView(reactTag: Int) = originalUIManager.resolveView(reactTag)
+}

package/android/detox/src/full/java/com/wix/detox/inquiry/ViewLifecycleRegistry.kt

@@ -0,0 +1,233 @@
+package com.wix.detox.inquiry
+
+import android.view.View
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicLong
+
+/**
+ * Registry to track various lifecycle events of Android Views.
+ * Uses WeakHashMap to prevent memory leaks and allows tracking of:
+ * - Mount events (when views are created/mounted)
+ * - Animation events (when views are animated)
+ * - Update events (when views are updated)
+ * - Custom events (extensible for future needs)
+ */
+object ViewLifecycleRegistry {
+    private val viewLifecycleInfo = ConcurrentHashMap<View, ViewLifecycleInfo>()
+    private val lastCleanupTime = AtomicLong(0)
+    private val cleanupIntervalMs = 30_000L // Clean up every 30 seconds
+
+    /**
+     * Data class to hold lifecycle information for a view
+     */
+    data class ViewLifecycleInfo(
+        val view: View,
+        val mountTime: Long = 0,
+        val lastAnimateTime: Long = 0,
+        val lastUpdateTime: Long = 0,
+        val animationCount: Int = 0,
+        val updateCount: Int = 0,
+        val customEvents: MutableMap<String, Long> = mutableMapOf()
+    ) {
+        fun wasRecentlyAnimated(windowMs: Long = 1500): Boolean {
+            if (lastAnimateTime == 0L) return false
+            return System.currentTimeMillis() - lastAnimateTime <= windowMs
+        }
+
+        fun wasRecentlyUpdated(windowMs: Long = 1000): Boolean {
+            if (lastUpdateTime == 0L) return false
+            return System.currentTimeMillis() - lastUpdateTime <= windowMs
+        }
+
+        fun wasRecentlyMounted(windowMs: Long = 5000): Boolean {
+            if (mountTime == 0L) return false
+            return System.currentTimeMillis() - mountTime <= windowMs
+        }
+
+        fun hasCustomEvent(eventType: String, windowMs: Long = 2000): Boolean {
+            val eventTime = customEvents[eventType] ?: return false
+            return System.currentTimeMillis() - eventTime <= windowMs
+        }
+    }
+
+    /**
+     * Mark a view as mounted
+     */
+    fun markMounted(view: View) {
+        val now = System.currentTimeMillis()
+        viewLifecycleInfo.compute(view) { _, existing ->
+            existing?.copy(mountTime = now) ?: ViewLifecycleInfo(view, mountTime = now)
+        }
+        performPeriodicCleanup()
+    }
+
+    /**
+     * Mark a view as animated
+     */
+    fun markAnimated(view: View) {
+        val now = System.currentTimeMillis()
+
+        viewLifecycleInfo.compute(view) { _, existing ->
+            val info = existing ?: ViewLifecycleInfo(view)
+            info.copy(
+                lastAnimateTime = now,
+                animationCount = info.animationCount + 1
+            )
+        }
+        performPeriodicCleanup()
+    }
+
+    /**
+     * Mark a view as updated
+     */
+    fun markUpdated(view: View) {
+        val now = System.currentTimeMillis()
+        viewLifecycleInfo.compute(view) { _, existing ->
+            val info = existing ?: ViewLifecycleInfo(view)
+            info.copy(
+                lastUpdateTime = now,
+                updateCount = info.updateCount + 1
+            )
+        }
+        performPeriodicCleanup()
+    }
+
+    /**
+     * Mark a custom event for a view
+     */
+    fun markCustomEvent(view: View, eventType: String) {
+        val now = System.currentTimeMillis()
+        viewLifecycleInfo.compute(view) { _, existing ->
+            val info = existing ?: ViewLifecycleInfo(view)
+            info.customEvents[eventType] = now
+            info
+        }
+        performPeriodicCleanup()
+    }
+
+    /**
+     * Check if a view was recently animated
+     */
+    fun wasRecentlyAnimated(view: View, windowMs: Long = 1500): Boolean {
+        return viewLifecycleInfo[view]?.wasRecentlyAnimated(windowMs) ?: false
+    }
+
+    /**
+     * Check if a view was recently updated
+     */
+    fun wasRecentlyUpdated(view: View, windowMs: Long = 1000): Boolean {
+        return viewLifecycleInfo[view]?.wasRecentlyUpdated(windowMs) ?: false
+    }
+
+    /**
+     * Check if a view was recently mounted
+     */
+    fun wasRecentlyMounted(view: View, windowMs: Long = 5000): Boolean {
+        return viewLifecycleInfo[view]?.wasRecentlyMounted(windowMs) ?: false
+    }
+
+    /**
+     * Check if a view has a custom event within the time window
+     */
+    fun hasCustomEvent(view: View, eventType: String, windowMs: Long = 2000): Boolean {
+        return viewLifecycleInfo[view]?.hasCustomEvent(eventType, windowMs) ?: false
+    }
+
+    /**
+     * Get lifecycle info for a view
+     */
+    fun getLifecycleInfo(view: View): ViewLifecycleInfo? {
+        return viewLifecycleInfo[view]
+    }
+
+    /**
+     * Get all views that were recently animated
+     */
+    fun getRecentlyAnimatedViews(windowMs: Long = 1500): List<View> {
+        return viewLifecycleInfo.keys.filter { wasRecentlyAnimated(it, windowMs) }
+    }
+
+    /**
+     * Get all views that were recently updated
+     */
+    fun getRecentlyUpdatedViews(windowMs: Long = 1000): List<View> {
+        return viewLifecycleInfo.keys.filter { wasRecentlyUpdated(it, windowMs) }
+    }
+
+    /**
+     * Get all views that were recently mounted
+     */
+    fun getRecentlyMountedViews(windowMs: Long = 5000): List<View> {
+        return viewLifecycleInfo.keys.filter { wasRecentlyMounted(it, windowMs) }
+    }
+
+    /**
+     * Get all views with a specific custom event
+     */
+    fun getViewsWithCustomEvent(eventType: String, windowMs: Long = 2000): List<View> {
+        return viewLifecycleInfo.keys.filter { hasCustomEvent(it, eventType, windowMs) }
+    }
+
+    /**
+     * Get statistics about the registry
+     */
+    fun getStats(): Map<String, Any> {
+        val totalViews = viewLifecycleInfo.size
+        val recentlyAnimated = getRecentlyAnimatedViews().size
+        val recentlyUpdated = getRecentlyUpdatedViews().size
+        val recentlyMounted = getRecentlyMountedViews().size
+
+        return mapOf(
+            "totalViews" to totalViews,
+            "recentlyAnimated" to recentlyAnimated,
+            "recentlyUpdated" to recentlyUpdated,
+            "recentlyMounted" to recentlyMounted
+        )
+    }
+
+    /**
+     * Clear all data (useful for testing)
+     */
+    fun clear() {
+        viewLifecycleInfo.clear()
+    }
+
+    /**
+     * Perform periodic cleanup to remove stale entries
+     */
+    private fun performPeriodicCleanup() {
+        val now = System.currentTimeMillis()
+        val lastCleanup = lastCleanupTime.get()
+
+        if (now - lastCleanup > cleanupIntervalMs &&
+            lastCleanupTime.compareAndSet(lastCleanup, now)) {
+
+            // Remove views that are no longer valid or haven't been accessed recently
+            val iterator = viewLifecycleInfo.iterator()
+            while (iterator.hasNext()) {
+                val entry = iterator.next()
+                val view = entry.key
+                val info = entry.value
+
+                // Remove if view is no longer valid or hasn't been accessed in 5 minutes
+                if (!isViewValid(view) || (now - info.lastAnimateTime > 300_000 &&
+                                          now - info.lastUpdateTime > 300_000 &&
+                                          now - info.mountTime > 300_000)) {
+                    iterator.remove()
+                }
+            }
+        }
+    }
+
+    /**
+     * Check if a view is still valid (not garbage collected)
+     */
+    private fun isViewValid(view: View): Boolean {
+        return try {
+            view.javaClass // Try to access the view
+            true
+        } catch (e: Exception) {
+            false
+        }
+    }
+}

package/android/detox/src/full/java/com/wix/detox/reactnative/idlingresources/uimodule/fabric/FabricUIManagerIdlingResources.kt

@@ -1,11 +1,13 @@
 package com.wix.detox.reactnative.idlingresources.uimodule.fabric
 
+import android.util.Log
 import android.view.Choreographer
 import androidx.test.espresso.IdlingResource
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.UIManagerHelper
 import com.facebook.react.uimanager.common.UIManagerType
 import com.wix.detox.reactnative.idlingresources.DetoxIdlingResource
+import com.wix.detox.inquiry.ViewLifecycleRegistry
 import org.joor.Reflect
 import java.util.concurrent.ConcurrentLinkedQueue
 
@@ -15,10 +17,15 @@ class FabricUIManagerIdlingResources(
 ) : DetoxIdlingResource(), Choreographer.FrameCallback  {
 
     override fun checkIdle(): Boolean {
-        return if (getViewCommandMountItemsSize() == 0 && getMountItemsSize() == 0) {
+        val mountItemsSize = getMountItemsSize()
+        val viewCommandMountItemsSize = getViewCommandMountItemsSize()
+
+        return if (mountItemsSize == 0 && viewCommandMountItemsSize == 0) {
             notifyIdle()
             true
         } else {
+            // Track mount items to identify animated views
+            trackMountItems()
             Choreographer.getInstance().postFrameCallback(this)
             false
         }
@@ -67,4 +74,166 @@ class FabricUIManagerIdlingResources(
         return viewCommandMountItems.size
     }
 
+    /**
+     * Track mount items to identify animated views.
+     * This is called when the UI manager is busy processing mount items.
+     */
+    private fun trackMountItems() {
+        try {
+            val mountItemDispatcher = getMountItemDispatcher()
+            val mountItems = Reflect.on(mountItemDispatcher).field("mMountItems").get<ConcurrentLinkedQueue<*>>()
+
+            // Track each mount item to identify animated views
+            mountItems.forEach { mountItem ->
+                trackMountItem(mountItem)
+            }
+        } catch (e: Exception) {
+            // Silently ignore errors to avoid breaking the idling resource
+        }
+    }
+
+    /**
+     * Track individual mount item to identify animated views.
+     */
+    private fun trackMountItem(mountItem: Any) {
+        try {
+            val mountItemClass = mountItem.javaClass.simpleName
+            Log.i("DetoxFabricDebug", "Processing mount item: $mountItemClass")
+
+            when (mountItemClass) {
+                "IntBufferBatchMountItem" -> {
+                    Log.i("DetoxFabricDebug", "Found IntBufferBatchMountItem - processing animated props")
+                    // This is where animated props get applied
+                    trackIntBufferBatchMountItem(mountItem)
+                }
+                "CreateMountItem" -> {
+                    Log.i("DetoxFabricDebug", "Found CreateMountItem - processing view creation")
+                    // Track view creation
+                    trackCreateMountItem(mountItem)
+                }
+                else -> {
+                    Log.i("DetoxFabricDebug", "Unknown mount item type: $mountItemClass")
+                }
+                // Add other mount item types as needed
+            }
+        } catch (e: Exception) {
+            Log.e("DetoxFabricDebug", "Error processing mount item", e)
+        }
+    }
+
+    /**
+     * Track IntBufferBatchMountItem which contains animated prop updates.
+     */
+    private fun trackIntBufferBatchMountItem(mountItem: Any) {
+        try {
+            // Use reflection to access the mount item's data
+            val intBuffer = Reflect.on(mountItem).field("mIntBuffer").get<IntArray>()
+            val objBuffer = Reflect.on(mountItem).field("mObjBuffer").get<Array<Any>>()
+
+            var i = 0
+            var j = 0
+
+            while (i < intBuffer.size) {
+                val instruction = intBuffer[i++]
+
+                when (instruction) {
+                    32 -> { // INSTRUCTION_UPDATE_PROPS
+                        val viewTag = intBuffer[i++]
+                        val props = objBuffer[j++] as? com.facebook.react.bridge.ReadableMap
+
+                        // Track animated view update
+                        trackAnimatedViewUpdate(viewTag, props)
+                    }
+                    2 -> { // INSTRUCTION_CREATE
+                        val viewTag = intBuffer[i++]
+                        // Mark as mounted
+                        val fabricUIManager = UIManagerHelper.getUIManager(reactContext, UIManagerType.FABRIC)
+                        val view = getViewByTag(fabricUIManager as Any, viewTag)
+                        view?.let { ViewLifecycleRegistry.markMounted(it) }
+                    }
+                    8 -> { // INSTRUCTION_INSERT
+                        val parentTag = intBuffer[i++]
+                        val viewTag = intBuffer[i++]
+                        val index = intBuffer[i++]
+                        // Mark as mounted
+                        val fabricUIManager = UIManagerHelper.getUIManager(reactContext, UIManagerType.FABRIC)
+                        val view = getViewByTag(fabricUIManager as Any, viewTag)
+                        view?.let { ViewLifecycleRegistry.markMounted(it) }
+                    }
+                    16 -> { // INSTRUCTION_REMOVE
+                        val parentTag = intBuffer[i++]
+                        val viewTag = intBuffer[i++]
+                        val index = intBuffer[i++]
+                        // View is being removed, no need to track
+                    }
+                    128 -> { // INSTRUCTION_UPDATE_LAYOUT
+                        val viewTag = intBuffer[i++]
+                        // Mark as updated
+                        val fabricUIManager = UIManagerHelper.getUIManager(reactContext, UIManagerType.FABRIC)
+                        val view = getViewByTag(fabricUIManager as Any, viewTag)
+                        view?.let { ViewLifecycleRegistry.markUpdated(it) }
+                    }
+                    // Skip other instruction types
+                }
+            }
+        } catch (e: Exception) {
+            // Silently ignore errors to avoid breaking the idling resource
+        }
+    }
+
+    /**
+     * Track CreateMountItem for view creation.
+     */
+    private fun trackCreateMountItem(mountItem: Any) {
+        try {
+            val viewTag = Reflect.on(mountItem).field("mReactTag").get<Int>()
+            // We can't get the actual View here, but we can track the tag
+            // The actual View will be available when it's mounted
+        } catch (e: Exception) {
+            // Silently ignore errors
+        }
+    }
+
+    /**
+     * Track animated view update.
+     */
+    private fun trackAnimatedViewUpdate(viewTag: Int, props: com.facebook.react.bridge.ReadableMap?) {
+        try {
+            // Get the actual Android View
+            val fabricUIManager = UIManagerHelper.getUIManager(reactContext, UIManagerType.FABRIC)
+            val view = getViewByTag(fabricUIManager as Any, viewTag)
+
+            if (view != null) {
+                com.wix.detox.inquiry.DetoxFabricAnimationHook.hookSynchronouslyUpdateViewOnUIThread(viewTag, props, fabricUIManager as com.facebook.react.fabric.FabricUIManager)
+            }
+        } catch (e: Exception) {
+            // Silently ignore errors to avoid breaking the idling resource
+        }
+    }
+
+    /**
+     * Get Android View by React Native view tag using correct Fabric APIs.
+     */
+    private fun getViewByTag(fabricUIManager: Any, viewTag: Int): android.view.View? {
+        return try {
+            // Get MountingManager from FabricUIManager
+            val mountingManager = Reflect.on(fabricUIManager).field("mMountingManager").get<Any>()
+
+            // Get SurfaceMountingManager for the view
+            val getSurfaceManagerMethod = mountingManager.javaClass.getMethod("getSurfaceManagerForView", Int::class.java)
+            val surfaceMountingManager = getSurfaceManagerMethod.invoke(mountingManager, viewTag)
+
+            if (surfaceMountingManager != null) {
+                // Get the actual Android View
+                val getViewMethod = surfaceMountingManager.javaClass.getMethod("getView", Int::class.java)
+                getViewMethod.invoke(surfaceMountingManager, viewTag) as? android.view.View
+            } else {
+                null
+            }
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "detox",
   "description": "E2E tests and automation for mobile",
-  "version": "20.43.0",
+  "version": "20.44.0-smoke.1",
   "bin": {
     "detox": "local-cli/cli.js"
   },
@@ -120,5 +120,5 @@
   "browserslist": [
     "node 14"
   ],
-  "gitHead": "28c2bb5d49a78a0b7103ecd15a8d6a148b1f7d3d"
+  "gitHead": "5e0b38a97eccb64d73369b1a3ccbd9c31ecde284"
 }

package/Detox-android/com/wix/detox/20.43.0/detox-20.43.0-sources.jar.md5

@@ -1 +0,0 @@
-016ffb2e4c490e01beafd1146a3a8353

package/Detox-android/com/wix/detox/20.43.0/detox-20.43.0-sources.jar.sha1

@@ -1 +0,0 @@
-097c3dad67f1dea0e2cdf756732aff413940b2c3

package/Detox-android/com/wix/detox/20.43.0/detox-20.43.0-sources.jar.sha256

@@ -1 +0,0 @@
-db8f2eb0cd02d2373018228e130132dc7d206625fcc2d7a54e6d9fa5a2d1f2e0

package/Detox-android/com/wix/detox/20.43.0/detox-20.43.0-sources.jar.sha512

@@ -1 +0,0 @@
-011ea72685f18e86f4ab86048a93fa47ff5e213bfcc83b9c7eb3fec558668c895f09479a083cca75fa0e0b4306e7ac808db22d2dbdb16f7732bfd03df2a7f929

package/Detox-android/com/wix/detox/20.43.0/detox-20.43.0.aar.md5

@@ -1 +0,0 @@
-c9638ce7992b4b6dfe4f83030aef5169

package/Detox-android/com/wix/detox/20.43.0/detox-20.43.0.aar.sha1

@@ -1 +0,0 @@
-a2ed68ce4b428750daf9a3542447273ee1c171d3

package/Detox-android/com/wix/detox/20.43.0/detox-20.43.0.aar.sha256

@@ -1 +0,0 @@
-52c115c682f497fb9925388a3e3b607e6c8a2742a71547e2aeca2457c048c6c6

package/Detox-android/com/wix/detox/20.43.0/detox-20.43.0.aar.sha512

@@ -1 +0,0 @@
-1ff3bc63cd2de2916880bec7572f7fd48612955d6192a094af89edc97daa88c03b7d646999dda185900875337de07898e523e96067e284fd1137ce35c1c18baa

package/Detox-android/com/wix/detox/20.43.0/detox-20.43.0.pom.md5

@@ -1 +0,0 @@
-17c5883f432236d65c08fef7086af8b6

package/Detox-android/com/wix/detox/20.43.0/detox-20.43.0.pom.sha1

@@ -1 +0,0 @@
-06dfe524847a88faedbf0360272b4aaff6be4da0

package/Detox-android/com/wix/detox/20.43.0/detox-20.43.0.pom.sha256

@@ -1 +0,0 @@
-5394023ab0482b86513f82bfb0072233bb04d5b809a05d804085a2cd59c677a5

package/Detox-android/com/wix/detox/20.43.0/detox-20.43.0.pom.sha512

@@ -1 +0,0 @@
-8433d0f377655a489d92691746233edc865b1040318b708f0a451aade0254bda5989a7bcd042ffe8ecd3e65fc636b0e945a58c86d616b590e6c24ed8974402a1