@apollohg/react-native-prose-editor 0.5.15 → 0.5.17

package/android/src/main/java/com/apollohg/editor/NativeEditorExpoView.kt

@@ -5,7 +5,10 @@ import android.content.Context
 import android.content.ContextWrapper
 import android.graphics.Rect
 import android.graphics.RectF
+import android.os.Handler
+import android.os.Looper
 import android.os.SystemClock
+import android.util.Log
 import android.view.Gravity
 import android.view.MotionEvent
 import android.view.View
@@ -20,8 +23,334 @@ import expo.modules.kotlin.viewevent.EventDispatcher
 import expo.modules.kotlin.views.ExpoView
 import org.json.JSONArray
 import org.json.JSONObject
+import java.lang.ref.WeakReference
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.WeakHashMap
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicReference
 import uniffi.editor_core.*
 
+private const val DESTROY_INVALIDATION_AWAIT_TIMEOUT_MS = 250L
+
+private class WeakNativeEditorExpoView private constructor(
+    val view: WeakReference<NativeEditorExpoView?>
+) {
+    constructor(view: NativeEditorExpoView) : this(WeakReference(view))
+
+    companion object {
+        fun cleared(): WeakNativeEditorExpoView =
+            WeakNativeEditorExpoView(WeakReference<NativeEditorExpoView?>(null))
+    }
+}
+
+internal object NativeEditorViewRegistry {
+    private data class CommandPreparationSnapshot(
+        val view: NativeEditorExpoView?,
+        val isDetached: Boolean,
+        val isDestroyed: Boolean
+    )
+
+    private val viewsByEditorId = mutableMapOf<Long, WeakNativeEditorExpoView>()
+    private val detachedEditorOwnersByEditorId = mutableMapOf<Long, WeakNativeEditorExpoView>()
+    private val destroyedEditorIds = mutableSetOf<Long>()
+    private val mainHandler = Handler(Looper.getMainLooper())
+
+    @Synchronized
+    fun markEditorCreated(editorId: Long) {
+        if (editorId == 0L) return
+        destroyedEditorIds.remove(editorId)
+    }
+
+    @Synchronized
+    fun register(editorId: Long, view: NativeEditorExpoView): Boolean {
+        if (editorId == 0L) return false
+        if (destroyedEditorIds.contains(editorId)) return false
+        viewsByEditorId[editorId] = WeakNativeEditorExpoView(view)
+        detachedEditorOwnersByEditorId.remove(editorId)
+        return true
+    }
+
+    @Synchronized
+    fun unregister(
+        editorId: Long,
+        view: NativeEditorExpoView,
+        blockCommandsUntilRegistered: Boolean = false
+    ) {
+        if (editorId == 0L) return
+        val registeredView = viewsByEditorId[editorId]?.view?.get()
+        if (registeredView === view) {
+            viewsByEditorId.remove(editorId)
+        }
+        if (blockCommandsUntilRegistered) {
+            detachedEditorOwnersByEditorId[editorId] = WeakNativeEditorExpoView(view)
+        } else {
+            val detachedOwner = detachedEditorOwnersByEditorId[editorId]?.view?.get()
+            if (registeredView === view || detachedOwner === view) {
+                detachedEditorOwnersByEditorId.remove(editorId)
+            }
+        }
+    }
+
+    @Synchronized
+    fun isDestroyed(editorId: Long): Boolean = destroyedEditorIds.contains(editorId)
+
+    @Synchronized
+    internal fun forceDetachedOwnerClearedForTesting(editorId: Long) {
+        detachedEditorOwnersByEditorId[editorId] = WeakNativeEditorExpoView.cleared()
+    }
+
+    fun invalidateDestroyedEditor(editorId: Long) {
+        if (editorId == 0L) return
+        val affectedViews = synchronized(this) {
+            destroyedEditorIds.add(editorId)
+            val views = listOfNotNull(
+                viewsByEditorId.remove(editorId)?.view?.get(),
+                detachedEditorOwnersByEditorId.remove(editorId)?.view?.get()
+            ).distinct()
+            views
+        }
+        if (affectedViews.isEmpty()) return
+        val invalidate = Runnable {
+            affectedViews.forEach { view ->
+                view.handleEditorDestroyed(editorId)
+            }
+        }
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            invalidate.run()
+        } else {
+            val latch = CountDownLatch(1)
+            val posted = mainHandler.post {
+                try {
+                    invalidate.run()
+                } finally {
+                    latch.countDown()
+                }
+            }
+            if (!posted) return
+            try {
+                latch.await(DESTROY_INVALIDATION_AWAIT_TIMEOUT_MS, TimeUnit.MILLISECONDS)
+            } catch (_: InterruptedException) {
+                Thread.currentThread().interrupt()
+            } catch (_: Throwable) {
+                return
+            }
+        }
+    }
+
+    fun prepareForCommandJSON(editorId: Long): String {
+        val prepare = {
+            val snapshot = synchronized(this) {
+                val isDestroyed = destroyedEditorIds.contains(editorId)
+                if (isDestroyed) {
+                    return@synchronized CommandPreparationSnapshot(
+                        view = null,
+                        isDetached = false,
+                        isDestroyed = true
+                    )
+                }
+                val candidate = viewsByEditorId[editorId]?.view?.get()
+                if (candidate == null) {
+                    viewsByEditorId.remove(editorId)
+                }
+                val detachedOwner = detachedEditorOwnersByEditorId[editorId]?.view?.get()
+                val isDetached = if (detachedOwner == null) {
+                    detachedEditorOwnersByEditorId.remove(editorId)
+                    false
+                } else {
+                    true
+                }
+                CommandPreparationSnapshot(
+                    view = candidate,
+                    isDetached = isDetached,
+                    isDestroyed = false
+                )
+            }
+            snapshot.view?.prepareForEditorCommandJSON()
+                ?: commandPreparationJSON(
+                    ready = !snapshot.isDetached && !snapshot.isDestroyed,
+                    blockedReason = if (snapshot.isDestroyed) {
+                        "destroyed"
+                    } else if (snapshot.isDetached) {
+                        "detached"
+                    } else {
+                        null
+                    }
+                )
+        }
+
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            return prepare()
+        }
+
+        val result = AtomicReference(commandPreparationJSON(ready = false, blockedReason = "unknown"))
+        val state = AtomicInteger(PREFLIGHT_STATE_QUEUED)
+        val latch = CountDownLatch(1)
+        if (!mainHandler.post {
+            try {
+                if (state.compareAndSet(PREFLIGHT_STATE_QUEUED, PREFLIGHT_STATE_RUNNING)) {
+                    result.set(prepare())
+                    state.set(PREFLIGHT_STATE_DONE)
+                }
+            } finally {
+                latch.countDown()
+            }
+        }) {
+            return commandPreparationJSON(ready = false, blockedReason = "unknown")
+        }
+        try {
+            if (!latch.await(DESTROY_INVALIDATION_AWAIT_TIMEOUT_MS, TimeUnit.MILLISECONDS)) {
+                if (state.compareAndSet(PREFLIGHT_STATE_QUEUED, PREFLIGHT_STATE_CANCELLED)) {
+                    return commandPreparationJSON(ready = false, blockedReason = "unknown")
+                }
+                if (state.get() == PREFLIGHT_STATE_RUNNING) {
+                    latch.await()
+                    return result.get()
+                }
+                return commandPreparationJSON(ready = false, blockedReason = "unknown")
+            }
+        } catch (_: InterruptedException) {
+            var interrupted = true
+            if (state.compareAndSet(PREFLIGHT_STATE_QUEUED, PREFLIGHT_STATE_CANCELLED)) {
+                Thread.currentThread().interrupt()
+                return commandPreparationJSON(ready = false, blockedReason = "unknown")
+            }
+            while (state.get() == PREFLIGHT_STATE_RUNNING) {
+                try {
+                    latch.await()
+                    break
+                } catch (_: InterruptedException) {
+                    interrupted = true
+                }
+            }
+            if (interrupted) {
+                Thread.currentThread().interrupt()
+            }
+            return if (state.get() == PREFLIGHT_STATE_DONE) {
+                result.get()
+            } else {
+                commandPreparationJSON(ready = false, blockedReason = "unknown")
+            }
+        }
+        return result.get()
+    }
+
+    fun commandPreparationJSON(
+        ready: Boolean,
+        updateJSON: String? = null,
+        blockedReason: String? = null
+    ): String {
+        return JSONObject().apply {
+            put("ready", ready)
+            if (updateJSON != null) {
+                put("updateJSON", updateJSON)
+            }
+            if (!ready && blockedReason != null) {
+                put("blockedReason", blockedReason)
+            }
+        }.toString()
+    }
+
+    private const val PREFLIGHT_STATE_QUEUED = 0
+    private const val PREFLIGHT_STATE_RUNNING = 1
+    private const val PREFLIGHT_STATE_CANCELLED = 2
+    private const val PREFLIGHT_STATE_DONE = 3
+}
+
+private object NativeEditorOutsideTapDispatcher {
+    private val dispatchers = WeakHashMap<Window, OutsideTapWindowCallback>()
+
+    fun register(window: Window, view: NativeEditorExpoView) {
+        val currentCallback = window.callback ?: return
+        val previousDispatcher = dispatchers[window]
+        val dispatcher = if (currentCallback is OutsideTapWindowCallback) {
+            previousDispatcher
+                ?.takeIf { it !== currentCallback }
+                ?.transferViewsTo(currentCallback)
+            currentCallback
+        } else {
+            OutsideTapWindowCallback(window, currentCallback).also { nextDispatcher ->
+                previousDispatcher?.transferViewsTo(nextDispatcher)
+                window.callback = nextDispatcher
+            }
+        }
+        dispatchers[window] = dispatcher
+        dispatcher.add(view)
+    }
+
+    fun unregister(window: Window, view: NativeEditorExpoView) {
+        val dispatcher = dispatchers[window] ?: return
+        if (!dispatcher.remove(view)) return
+        dispatchers.remove(window)
+        if (window.callback === dispatcher) {
+            window.callback = dispatcher.baseCallback
+        }
+    }
+
+    private class OutsideTapWindowCallback(
+        private val window: Window,
+        val baseCallback: Window.Callback
+    ) : Window.Callback by baseCallback {
+        private val views = mutableListOf<WeakReference<NativeEditorExpoView>>()
+        private var disabled = false
+
+        fun add(view: NativeEditorExpoView) {
+            prune()
+            if (views.any { it.get() === view }) return
+            views.add(WeakReference(view))
+        }
+
+        fun liveViews(): List<NativeEditorExpoView> {
+            prune()
+            return views.mapNotNull { it.get() }
+        }
+
+        fun transferViewsTo(target: OutsideTapWindowCallback) {
+            liveViews().forEach { target.add(it) }
+            views.clear()
+            disabled = true
+        }
+
+        fun remove(view: NativeEditorExpoView): Boolean {
+            views.removeAll { it.get()?.let { candidate -> candidate === view } != false }
+            return views.isEmpty()
+        }
+
+        override fun dispatchTouchEvent(event: MotionEvent): Boolean {
+            if (disabled) {
+                return baseCallback.dispatchTouchEvent(event)
+            }
+            val activeViews = liveViews()
+            if (event.action != MotionEvent.ACTION_DOWN || activeViews.isEmpty()) {
+                return baseCallback.dispatchTouchEvent(event)
+            }
+
+            val decisions = activeViews.map { view ->
+                view to view.shouldScheduleOutsideTapBlurForWindowEvent(event)
+            }
+            val result = baseCallback.dispatchTouchEvent(event)
+            decisions.forEach { (view, shouldBlur) ->
+                if (shouldBlur) {
+                    view.scheduleOutsideTapBlurFromWindowDispatcher()
+                } else {
+                    view.cancelOutsideTapBlurFromWindowDispatcher()
+                }
+            }
+            return result
+        }
+
+        private fun prune() {
+            views.removeAll { it.get() == null }
+            if (views.isEmpty() && window.callback === this) {
+                window.callback = baseCallback
+                if (dispatchers[window] === this) {
+                    dispatchers.remove(window)
+                }
+            }
+        }
+    }
+}
+
 /**
  * Expo Modules wrapper view that hosts a [RichTextEditorView] and bridges
  * editor events to React Native via [EventDispatcher].
@@ -43,13 +372,33 @@ class NativeEditorExpoView(
         }
     }
 
+    private sealed class PendingNativeAction {
+        data class ToolbarItemPress(val item: NativeToolbarItem) : PendingNativeAction()
+        data class MentionSuggestionSelect(val suggestion: NativeMentionSuggestion) : PendingNativeAction()
+    }
+
+    private data class PendingNativeActionScope(
+        val editorId: Long,
+        val documentVersion: Int?,
+        val allowedDocumentVersion: Int?,
+        val hadFocus: Boolean,
+        val hadVisibleToolbar: Boolean,
+        val selectionAnchor: Int?,
+        val selectionHead: Int?,
+        val mentionAnchor: Int? = null,
+        val mentionHead: Int? = null,
+        val mentionQuery: String? = null
+    )
+
     val richTextView: RichTextEditorView = RichTextEditorView(context)
     private val keyboardToolbarView = EditorKeyboardToolbarView(context)
+    private val mainHandler = Handler(Looper.getMainLooper())
 
     private val onEditorUpdate by EventDispatcher<Map<String, Any>>()
     private val onSelectionChange by EventDispatcher<Map<String, Any>>()
     private val onFocusChange by EventDispatcher<Map<String, Any>>()
     private val onContentHeightChange by EventDispatcher<Map<String, Any>>()
+    private val onEditorReady by EventDispatcher<Map<String, Any>>()
     @Suppress("unused")
     private val onToolbarAction by EventDispatcher<Map<String, Any>>()
     @Suppress("unused")
@@ -57,34 +406,85 @@ class NativeEditorExpoView(
 
     /** Guard flag: when true, editor updates originated from JS and should not echo back. */
     var isApplyingJSUpdate = false
+    internal var blockEditorUpdatePreflightForTesting = false
+    internal var blockThemePreflightForTesting = false
+    internal var onToolbarActionForTesting: ((Map<String, Any>) -> Unit)? = null
+    internal var onAddonEventForTesting: ((Map<String, Any>) -> Unit)? = null
+    internal var onFocusChangeForTesting: ((Map<String, Any>) -> Unit)? = null
+    internal var onEditorReadyForTesting: ((Map<String, Any>) -> Unit)? = null
+    internal var onRefreshToolbarStateFromEditorSelectionForTesting: (() -> String?)? = null
+    internal var onBeforePrepareForEditorCommandForTesting: (() -> Unit)? = null
+    private var isAttachedToNativeWindow = false
     private var didApplyAutoFocus = false
     private var heightBehavior = EditorHeightBehavior.FIXED
     private var lastEmittedContentHeight = 0
-    private var outsideTapWindowCallback: Window.Callback? = null
-    private var previousWindowCallback: Window.Callback? = null
+    private var outsideTapWindow: Window? = null
     private var toolbarFramesInWindow: List<RectF> = emptyList()
     private var lastToolbarTouchUptimeMs: Long? = null
     private var pendingOutsideTapBlur: Runnable? = null
     private var pendingKeyboardDismiss: Runnable? = null
+    private var pendingToolbarRefocus: Runnable? = null
+    private var pendingToolbarRefocusEditorId: Long? = null
+    private var pendingToolbarRefocusGeneration = 0
+    private var autoFocusRequested = false
     private var addons = NativeEditorAddons(null)
     private var mentionQueryState: MentionQueryState? = null
     private var lastMentionEventJson: String? = null
+    private var lastMentionEventEditorId: Long? = null
     private var lastThemeJson: String? = null
+    private var pendingThemeJson: String? = null
+    private var hasPendingTheme = false
+    private var pendingThemeRetryScheduled = false
+    private var pendingThemeRetryEditorId: Long? = null
+    private var pendingThemeRetryGeneration = 0
+    private var pendingThemeRetryAttempts = 0
     private var lastAddonsJson: String? = null
     private var lastRemoteSelectionsJson: String? = null
     private var lastToolbarItemsJson: String? = null
     private var lastToolbarFrameJson: String? = null
+    private var lastDocumentVersion: Int? = null
     private var toolbarState = NativeToolbarState.empty
     private var showsToolbar = true
     private var toolbarPlacement = ToolbarPlacement.KEYBOARD
     private var currentImeBottom = 0
     private var pendingEditorUpdateJson: String? = null
+    private var pendingEditorUpdateEditorId: Long? = null
     private var pendingEditorUpdateRevision = 0
     private var appliedEditorUpdateRevision = 0
+    private var pendingEditorUpdateRetryScheduled = false
+    private var pendingEditorUpdateRetryEditorId: Long? = null
+    private var pendingEditorUpdateRetryGeneration = 0
+    private var pendingEditorUpdateRetryAttempts = 0
+    private var pendingEditorUpdateForcedRecoveryAttempted = false
+    private var pendingViewCommandUpdateJson: String? = null
+    private var pendingViewCommandUpdateEditorId: Long? = null
+    private var pendingViewCommandUpdateRetryScheduled = false
+    private var pendingViewCommandUpdateRetryGeneration = 0
+    private var pendingViewCommandUpdateRetryAttempts = 0
+    private var pendingPreflightWakeScheduled = false
+    private var pendingPreflightWakeGeneration = 0
+    private var pendingBlurRetry: Runnable? = null
+    private var pendingBlurRetryEditorId: Long? = null
+    private var pendingBlurRetryGeneration = 0
+    private var pendingBlurRetryAttempts = 0
+    private var pendingDetachPreflightRetryScheduled = false
+    private var pendingDetachPreflightRetryEditorId: Long? = null
+    private var pendingDetachPreflightRetryGeneration = 0
+    private var pendingDetachPreflightRetryAttempts = 0
+    private var pendingNativeAction: PendingNativeAction? = null
+    private var pendingNativeActionScope: PendingNativeActionScope? = null
+    private var pendingNativeActionRetryScheduled = false
+    private var pendingNativeActionRetryEditorId: Long? = null
+    private var pendingNativeActionRetryGeneration = 0
+    private var pendingNativeActionRetryAttempts = 0
+    private var lastReadyEditorId: Long? = null
 
     init {
         addView(richTextView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
         richTextView.editorEditText.editorListener = this
+        richTextView.onBeforeDetachedFromWindow = {
+            prepareForDetachFromWindow()
+        }
         keyboardToolbarView.onPressItem = { item ->
             handleToolbarItemPress(item)
         }
@@ -102,36 +502,130 @@ class NativeEditorExpoView(
         // Observe EditText focus changes.
         richTextView.editorEditText.setOnFocusChangeListener { _, hasFocus ->
             if (hasFocus) {
+                cancelPendingToolbarRefocus()
                 installOutsideTapBlurHandlerIfNeeded()
                 refreshMentionQuery()
             } else {
                 if (shouldPreserveFocusAfterToolbarTouch()) {
-                    richTextView.editorEditText.post {
-                        focus()
-                    }
+                    scheduleToolbarRefocus()
                     return@setOnFocusChangeListener
                 }
                 uninstallOutsideTapBlurHandler()
                 clearMentionQueryState()
+                clearPendingNativeActionRetry()
             }
             updateKeyboardToolbarVisibility()
-            val event = mapOf<String, Any>("isFocused" to hasFocus)
-            onFocusChange(event)
+            val event = mapOf<String, Any>(
+                "isFocused" to hasFocus,
+                "editorId" to richTextView.editorId
+            )
+            onFocusChangeForTesting?.invoke(event) ?: onFocusChange(event)
         }
     }
 
     fun setEditorId(id: Long) {
-        richTextView.editorId = id
+        if (id != 0L && NativeEditorViewRegistry.isDestroyed(id)) {
+            setEditorId(0L)
+            return
+        }
+        val previousEditorId = richTextView.editorId
+        if (previousEditorId == id && richTextView.editorEditText.editorId == id) {
+            if (id != 0L && isAttachedToNativeWindow) {
+                if (!NativeEditorViewRegistry.register(id, this)) {
+                    handleEditorDestroyed(id)
+                    return
+                }
+                applyPendingEditorUpdateIfNeeded()
+                applyPendingThemeIfNeeded()
+                refreshReadyStateIfSettled()
+                applyAutoFocusIfNeeded()
+            } else if (id != 0L) {
+                NativeEditorViewRegistry.unregister(
+                    id,
+                    this,
+                    blockCommandsUntilRegistered = true
+                )
+            }
+            return
+        }
+        if (previousEditorId != id) {
+            NativeEditorViewRegistry.unregister(previousEditorId, this)
+            lastDocumentVersion = null
+            cancelPendingToolbarRefocus()
+            cancelPendingEditorUpdateRetry()
+            if (pendingEditorUpdateEditorId != null && pendingEditorUpdateEditorId != id) {
+                clearPendingEditorUpdateState()
+            }
+            appliedEditorUpdateRevision = 0
+            clearPendingViewCommandUpdateRetry()
+            cancelPendingThemeRetry()
+            if (hasPendingTheme) {
+                pendingThemeRetryEditorId = id
+            }
+            cancelPendingBlurRetry()
+            clearPendingNativeActionRetry()
+            clearMentionQueryState(resetLastEvent = true)
+            lastReadyEditorId = null
+        }
+        if (!isAttachedToNativeWindow) {
+            richTextView.setEditorIdWhileDetached(id)
+            if (id != 0L) {
+                NativeEditorViewRegistry.unregister(
+                    id,
+                    this,
+                    blockCommandsUntilRegistered = true
+                )
+            } else {
+                toolbarState = NativeToolbarState.empty
+                keyboardToolbarView.applyState(toolbarState)
+            }
+            return
+        }
+
+        if (hasPendingEditorUpdateForEditor(id)) {
+            richTextView.setEditorIdWhileDetached(id)
+            richTextView.rebindEditorIfNeeded(notifyListener = false)
+        } else {
+            richTextView.editorId = id
+        }
+        if (id != 0L) {
+            if (!NativeEditorViewRegistry.register(id, this)) {
+                handleEditorDestroyed(id)
+                return
+            }
+        } else {
+            toolbarState = NativeToolbarState.empty
+            keyboardToolbarView.applyState(toolbarState)
+        }
+        applyPendingEditorUpdateIfNeeded()
+        applyPendingThemeIfNeeded()
+        refreshReadyStateIfSettled()
+        applyAutoFocusIfNeeded()
     }
 
     fun setThemeJson(themeJson: String?) {
+        if (lastThemeJson == themeJson && !hasPendingTheme) return
+        pendingThemeJson = themeJson
+        hasPendingTheme = true
+        pendingThemeRetryEditorId = richTextView.editorId
+        pendingThemeRetryAttempts = 0
+        applyPendingThemeIfNeeded()
+    }
+
+    private fun applyThemeJson(themeJson: String?) {
         if (lastThemeJson == themeJson) return
         lastThemeJson = themeJson
         val theme = EditorTheme.fromJson(themeJson)
         richTextView.applyTheme(theme)
         keyboardToolbarView.applyTheme(theme?.toolbar)
         keyboardToolbarView.applyMentionTheme(theme?.mentions ?: addons.mentions?.theme)
+        keyboardToolbarView.requestLayout()
         updateKeyboardToolbarLayout()
+        updateEditorViewportInset(forceMeasureToolbar = true)
+        post {
+            updateKeyboardToolbarLayout()
+            updateEditorViewportInset(forceMeasureToolbar = true)
+        }
     }
 
     fun setHeightBehavior(rawHeightBehavior: String) {
@@ -159,6 +653,7 @@ class NativeEditorExpoView(
 
     fun setAddonsJson(addonsJson: String?) {
         if (lastAddonsJson == addonsJson) return
+        clearPendingNativeActionRetry()
         lastAddonsJson = addonsJson
         addons = NativeEditorAddons.fromJson(addonsJson)
         keyboardToolbarView.applyMentionTheme(richTextView.editorEditText.theme?.mentions ?: addons.mentions?.theme)
@@ -174,9 +669,12 @@ class NativeEditorExpoView(
     }
 
     fun setAutoFocus(autoFocus: Boolean) {
-        if (!autoFocus || didApplyAutoFocus) {
-            return
-        }
+        autoFocusRequested = autoFocus
+        applyAutoFocusIfNeeded()
+    }
+
+    private fun applyAutoFocusIfNeeded() {
+        if (!autoFocusRequested || didApplyAutoFocus || !canFocusCurrentEditor()) return
         didApplyAutoFocus = true
         focus()
     }
@@ -193,13 +691,34 @@ class NativeEditorExpoView(
         richTextView.editorEditText.setKeyboardType(keyboardType)
     }
 
+    fun setEditable(editable: Boolean) {
+        if (richTextView.editorEditText.isEditable == editable) return
+        if (!editable) {
+            cancelPendingToolbarRefocus()
+            clearPendingNativeActionRetry()
+        }
+        richTextView.editorEditText.isEditable = editable
+        updateKeyboardToolbarVisibility()
+    }
+
     fun setShowToolbar(showToolbar: Boolean) {
+        if (showsToolbar == showToolbar) return
+        if (!showToolbar) {
+            cancelPendingToolbarRefocus()
+            clearPendingNativeActionRetry()
+        }
         showsToolbar = showToolbar
         updateKeyboardToolbarVisibility()
     }
 
     fun setToolbarPlacement(rawToolbarPlacement: String?) {
-        toolbarPlacement = ToolbarPlacement.fromRaw(rawToolbarPlacement)
+        val nextPlacement = ToolbarPlacement.fromRaw(rawToolbarPlacement)
+        if (toolbarPlacement == nextPlacement) return
+        if (nextPlacement != ToolbarPlacement.KEYBOARD) {
+            cancelPendingToolbarRefocus()
+            clearPendingNativeActionRetry()
+        }
+        toolbarPlacement = nextPlacement
         updateKeyboardToolbarVisibility()
     }
 
@@ -209,6 +728,7 @@ class NativeEditorExpoView(
 
     fun setToolbarItemsJson(toolbarItemsJson: String?) {
         if (lastToolbarItemsJson == toolbarItemsJson) return
+        clearPendingNativeActionRetry()
         lastToolbarItemsJson = toolbarItemsJson
         keyboardToolbarView.setItems(NativeToolbarItem.fromJson(toolbarItemsJson))
     }
@@ -267,23 +787,495 @@ class NativeEditorExpoView(
         pendingEditorUpdateJson = editorUpdateJson
     }
 
+    fun setPendingEditorUpdateEditorId(editorUpdateEditorId: Long?) {
+        pendingEditorUpdateEditorId = editorUpdateEditorId
+    }
+
     fun setPendingEditorUpdateRevision(editorUpdateRevision: Int) {
+        if (pendingEditorUpdateRevision != editorUpdateRevision) {
+            pendingEditorUpdateRetryAttempts = 0
+            pendingEditorUpdateForcedRecoveryAttempted = false
+        }
         pendingEditorUpdateRevision = editorUpdateRevision
     }
 
+    private fun hasPendingEditorUpdateForEditor(editorId: Long): Boolean =
+        pendingEditorUpdateJson != null &&
+            pendingEditorUpdateRevision != 0 &&
+            pendingEditorUpdateRevision != appliedEditorUpdateRevision &&
+            pendingEditorUpdateEditorId == editorId
+
+    private fun hasPendingEditorUpdateForCurrentEditor(): Boolean =
+        hasPendingEditorUpdateForEditor(richTextView.editorId)
+
+    private fun pendingEditorUpdateCommandPreparationJSON(): String =
+        NativeEditorViewRegistry.commandPreparationJSON(
+            ready = false,
+            blockedReason = "pendingUpdate"
+        )
+
+    private fun shouldBlockEditorCommandForPendingUpdate(): Boolean =
+        hasPendingEditorUpdateForCurrentEditor()
+
+    private fun refreshReadyStateIfSettled() {
+        if (handleDestroyedCurrentEditorIfNeeded()) return
+        if (hasPendingEditorUpdateForCurrentEditor()) return
+        if (!isAttachedToNativeWindow) return
+        if (richTextView.editorEditText.editorId != richTextView.editorId) return
+        refreshToolbarStateFromEditorSelection()
+        refreshMentionQuery()
+        emitEditorReadyIfNeeded()
+    }
+
     fun applyPendingEditorUpdateIfNeeded() {
-        val updateJson = pendingEditorUpdateJson ?: return
+        if (handleDestroyedCurrentEditorIfNeeded()) return
         if (pendingEditorUpdateRevision == 0) return
-        if (pendingEditorUpdateRevision == appliedEditorUpdateRevision) return
-        appliedEditorUpdateRevision = pendingEditorUpdateRevision
-        applyEditorUpdate(updateJson)
+        val revision = pendingEditorUpdateRevision
+        val editorId = richTextView.editorId
+        val expectedEditorId = pendingEditorUpdateEditorId
+        if (expectedEditorId == null) return
+        if (expectedEditorId != editorId) return
+        if (pendingEditorUpdateJson == null) {
+            clearPendingEditorUpdateState(resetAppliedRevision = false)
+            refreshReadyStateIfSettled()
+            return
+        }
+        val updateJson = pendingEditorUpdateJson ?: return
+        if (pendingEditorUpdateRevision == appliedEditorUpdateRevision) {
+            clearPendingEditorUpdateState(resetAppliedRevision = false)
+            emitEditorReady(editorUpdateRevision = revision)
+            refreshReadyStateIfSettled()
+            return
+        }
+        if (editorId != 0L && !isAttachedToNativeWindow) return
+        val apply = Runnable {
+            if (editorId != richTextView.editorId) return@Runnable
+            if (expectedEditorId != richTextView.editorId) return@Runnable
+            if (editorId != 0L && !isAttachedToNativeWindow) return@Runnable
+            if (revision != pendingEditorUpdateRevision) return@Runnable
+            if (revision == appliedEditorUpdateRevision) {
+                clearPendingEditorUpdateState(resetAppliedRevision = false)
+                emitEditorReady(editorUpdateRevision = revision)
+                refreshReadyStateIfSettled()
+                return@Runnable
+            }
+            if (applyEditorUpdate(updateJson, scheduleViewCommandRetry = false)) {
+                appliedEditorUpdateRevision = revision
+                pendingEditorUpdateJson = null
+                pendingEditorUpdateEditorId = null
+                pendingEditorUpdateRevision = 0
+                pendingEditorUpdateRetryAttempts = 0
+                pendingEditorUpdateForcedRecoveryAttempted = false
+                cancelPendingEditorUpdateRetry()
+                emitEditorReady(editorUpdateRevision = revision)
+                refreshReadyStateIfSettled()
+            } else {
+                schedulePendingEditorUpdateRetry()
+            }
+        }
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            apply.run()
+        } else if (!post(apply)) {
+            richTextView.post(apply)
+        }
+    }
+
+    private fun clearPendingEditorUpdateState(resetAppliedRevision: Boolean = true) {
+        pendingEditorUpdateJson = null
+        pendingEditorUpdateEditorId = null
+        pendingEditorUpdateRevision = 0
+        if (resetAppliedRevision) {
+            appliedEditorUpdateRevision = 0
+        }
+        cancelPendingEditorUpdateRetry()
+    }
+
+    private fun cancelPendingEditorUpdateRetry() {
+        pendingEditorUpdateRetryScheduled = false
+        pendingEditorUpdateRetryEditorId = null
+        pendingEditorUpdateRetryAttempts = 0
+        pendingEditorUpdateForcedRecoveryAttempted = false
+        pendingEditorUpdateRetryGeneration += 1
+    }
+
+    private fun schedulePendingEditorUpdateRetry() {
+        if (pendingEditorUpdateRetryScheduled) return
+        val pastFastRetryBudget =
+            pendingEditorUpdateRetryAttempts >= MAX_PENDING_UPDATE_RETRY_ATTEMPTS
+        if (
+            pastFastRetryBudget &&
+            !pendingEditorUpdateForcedRecoveryAttempted &&
+            richTextView.editorId != 0L &&
+            richTextView.editorEditText.editorId == richTextView.editorId
+        ) {
+            pendingEditorUpdateForcedRecoveryAttempted = true
+            richTextView.editorEditText.discardTransientNativeInputForExternalRecovery()
+        }
+        if (!pastFastRetryBudget) {
+            pendingEditorUpdateRetryAttempts += 1
+        }
+        pendingEditorUpdateRetryEditorId = richTextView.editorId
+        pendingEditorUpdateRetryScheduled = true
+        pendingEditorUpdateRetryGeneration += 1
+        val retryGeneration = pendingEditorUpdateRetryGeneration
+        val delayMs = if (pastFastRetryBudget) {
+            PENDING_UPDATE_RECOVERY_RETRY_DELAY_MS
+        } else {
+            NATIVE_ACTION_RETRY_DELAY_MS * pendingEditorUpdateRetryAttempts
+        }
+        val retry = Runnable {
+            if (retryGeneration != pendingEditorUpdateRetryGeneration) return@Runnable
+            if (pendingEditorUpdateRetryEditorId != richTextView.editorId) {
+                clearPendingEditorUpdateState()
+                return@Runnable
+            }
+            pendingEditorUpdateRetryScheduled = false
+            pendingEditorUpdateRetryEditorId = null
+            applyPendingEditorUpdateIfNeeded()
+        }
+        mainHandler.postDelayed(retry, delayMs)
+    }
+
+    private fun clearPendingThemeRetry() {
+        pendingThemeJson = null
+        hasPendingTheme = false
+        cancelPendingThemeRetry()
+    }
+
+    private fun cancelPendingThemeRetry() {
+        pendingThemeRetryScheduled = false
+        pendingThemeRetryEditorId = null
+        pendingThemeRetryAttempts = 0
+        pendingThemeRetryGeneration += 1
+    }
+
+    private fun applyPendingThemeIfNeeded() {
+        if (handleDestroyedCurrentEditorIfNeeded()) return
+        if (!hasPendingTheme) return
+        val themeJson = pendingThemeJson
+        val editorId = richTextView.editorId
+        if (pendingThemeRetryEditorId != editorId) {
+            pendingThemeRetryEditorId = editorId
+        }
+        if (
+            blockThemePreflightForTesting ||
+            !richTextView.editorEditText.prepareForExternalEditorUpdate()
+        ) {
+            schedulePendingThemeRetry()
+            return
+        }
+        pendingThemeJson = null
+        hasPendingTheme = false
+        cancelPendingThemeRetry()
+        applyThemeJson(themeJson)
+    }
+
+    private fun schedulePendingThemeRetry() {
+        if (pendingThemeRetryScheduled) return
+        if (pendingThemeRetryAttempts >= MAX_PENDING_UPDATE_RETRY_ATTEMPTS) return
+        pendingThemeRetryAttempts += 1
+        pendingThemeRetryEditorId = richTextView.editorId
+        pendingThemeRetryScheduled = true
+        pendingThemeRetryGeneration += 1
+        val retryGeneration = pendingThemeRetryGeneration
+        val delayMs = NATIVE_ACTION_RETRY_DELAY_MS * pendingThemeRetryAttempts
+        val retry = Runnable {
+            if (retryGeneration != pendingThemeRetryGeneration) return@Runnable
+            if (pendingThemeRetryEditorId != richTextView.editorId) {
+                clearPendingThemeRetry()
+                return@Runnable
+            }
+            pendingThemeRetryScheduled = false
+            applyPendingThemeIfNeeded()
+        }
+        mainHandler.postDelayed(retry, delayMs)
+    }
+
+    private fun clearPendingViewCommandUpdateRetry() {
+        pendingViewCommandUpdateJson = null
+        pendingViewCommandUpdateEditorId = null
+        pendingViewCommandUpdateRetryScheduled = false
+        pendingViewCommandUpdateRetryAttempts = 0
+        pendingViewCommandUpdateRetryGeneration += 1
+    }
+
+    private fun scheduleViewCommandUpdateRetry(updateJson: String) {
+        if (pendingViewCommandUpdateJson != updateJson) {
+            pendingViewCommandUpdateRetryAttempts = 0
+        }
+        pendingViewCommandUpdateJson = updateJson
+        pendingViewCommandUpdateEditorId = richTextView.editorId
+        if (pendingViewCommandUpdateRetryScheduled) return
+        if (pendingViewCommandUpdateRetryAttempts >= MAX_PENDING_UPDATE_RETRY_ATTEMPTS) return
+        pendingViewCommandUpdateRetryAttempts += 1
+        pendingViewCommandUpdateRetryScheduled = true
+        pendingViewCommandUpdateRetryGeneration += 1
+        val retryGeneration = pendingViewCommandUpdateRetryGeneration
+        val delayMs = NATIVE_ACTION_RETRY_DELAY_MS * pendingViewCommandUpdateRetryAttempts
+        val retry = Runnable {
+            if (retryGeneration != pendingViewCommandUpdateRetryGeneration) return@Runnable
+            val retryJson = pendingViewCommandUpdateJson ?: run {
+                pendingViewCommandUpdateRetryScheduled = false
+                return@Runnable
+            }
+            if (pendingViewCommandUpdateEditorId != richTextView.editorId || richTextView.editorId == 0L) {
+                clearPendingViewCommandUpdateRetry()
+                return@Runnable
+            }
+            if (handleDestroyedCurrentEditorIfNeeded()) {
+                clearPendingViewCommandUpdateRetry()
+                return@Runnable
+            }
+            pendingViewCommandUpdateRetryScheduled = false
+            if (applyEditorUpdate(retryJson, scheduleViewCommandRetry = true)) {
+                clearPendingViewCommandUpdateRetry()
+            }
+        }
+        mainHandler.postDelayed(retry, delayMs)
+    }
+
+    private fun schedulePendingPreflightWake() {
+        if (pendingPreflightWakeScheduled) return
+        pendingPreflightWakeScheduled = true
+        pendingPreflightWakeGeneration += 1
+        val wakeGeneration = pendingPreflightWakeGeneration
+        mainHandler.post {
+            if (wakeGeneration != pendingPreflightWakeGeneration) return@post
+            pendingPreflightWakeScheduled = false
+            wakePendingPreflightWork()
+        }
+    }
+
+    private fun cancelPendingPreflightWake() {
+        pendingPreflightWakeScheduled = false
+        pendingPreflightWakeGeneration += 1
+    }
+
+    private fun wakePendingPreflightWork() {
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            schedulePendingPreflightWake()
+            return
+        }
+        if (handleDestroyedCurrentEditorIfNeeded()) return
+        if (pendingEditorUpdateJson != null) {
+            pendingEditorUpdateRetryAttempts = 0
+            pendingEditorUpdateForcedRecoveryAttempted = false
+            applyPendingEditorUpdateIfNeeded()
+        }
+        if (hasPendingTheme) {
+            pendingThemeRetryAttempts = 0
+            applyPendingThemeIfNeeded()
+        }
+        pendingViewCommandUpdateJson?.let { updateJson ->
+            pendingViewCommandUpdateRetryAttempts = 0
+            pendingViewCommandUpdateRetryScheduled = false
+            pendingViewCommandUpdateRetryGeneration += 1
+            if (applyEditorUpdate(updateJson, scheduleViewCommandRetry = true)) {
+                clearPendingViewCommandUpdateRetry()
+            }
+        }
+        retryPendingNativeActionFromWake()
+    }
+
+    private fun clearPendingNativeActionRetry() {
+        pendingNativeAction = null
+        pendingNativeActionScope = null
+        pendingNativeActionRetryEditorId = null
+        pendingNativeActionRetryScheduled = false
+        pendingNativeActionRetryAttempts = 0
+        pendingNativeActionRetryGeneration += 1
+    }
+
+    private fun currentNativeActionScope(action: PendingNativeAction): PendingNativeActionScope {
+        val selection = richTextView.editorEditText.currentScalarSelection()
+        val mentionScope = when (action) {
+            is PendingNativeAction.MentionSuggestionSelect ->
+                mentionQueryState ?: addons.mentions?.let { currentMentionQueryState(it.trigger) }
+            is PendingNativeAction.ToolbarItemPress -> null
+        }
+        return PendingNativeActionScope(
+            editorId = richTextView.editorId,
+            documentVersion = lastDocumentVersion,
+            allowedDocumentVersion = documentVersionFromUpdateJSON(pendingEditorUpdateJson),
+            hadFocus = isEditorEffectivelyFocusedForNativeAction(),
+            hadVisibleToolbar = isNativeActionToolbarVisible(action),
+            selectionAnchor = selection?.first,
+            selectionHead = selection?.second,
+            mentionAnchor = mentionScope?.anchor,
+            mentionHead = mentionScope?.head,
+            mentionQuery = mentionScope?.query
+        )
+    }
+
+    private fun isPendingNativeActionScopeCurrent(
+        action: PendingNativeAction,
+        scope: PendingNativeActionScope
+    ): Boolean {
+        if (scope.editorId != richTextView.editorId) return false
+        if (scope.hadFocus != isEditorEffectivelyFocusedForNativeAction()) return false
+        if (scope.hadVisibleToolbar != isNativeActionToolbarVisible(action)) return false
+        if (
+            scope.documentVersion != lastDocumentVersion &&
+            (scope.allowedDocumentVersion == null || scope.allowedDocumentVersion != lastDocumentVersion)
+        ) {
+            return false
+        }
+        val selection = richTextView.editorEditText.currentScalarSelection()
+        if (scope.selectionAnchor != selection?.first || scope.selectionHead != selection?.second) {
+            return false
+        }
+        if (action is PendingNativeAction.MentionSuggestionSelect) {
+            val mentions = addons.mentions ?: return false
+            val currentQuery = currentMentionQueryState(mentions.trigger) ?: return false
+            if (
+                scope.mentionAnchor != currentQuery.anchor ||
+                scope.mentionHead != currentQuery.head ||
+                scope.mentionQuery != currentQuery.query
+            ) {
+                return false
+            }
+        }
+        return true
+    }
+
+    private fun isNativeActionToolbarVisible(action: PendingNativeAction): Boolean {
+        if (!showsToolbar || toolbarPlacement != ToolbarPlacement.KEYBOARD) return false
+        if (keyboardToolbarView.parent == null || keyboardToolbarView.visibility != View.VISIBLE) return false
+        if (action is PendingNativeAction.MentionSuggestionSelect) {
+            return keyboardToolbarView.isShowingMentionSuggestions
+        }
+        return true
+    }
+
+    private fun isEditorEffectivelyFocusedForNativeAction(): Boolean =
+        richTextView.editorEditText.hasFocus() ||
+            (pendingToolbarRefocus != null && pendingToolbarRefocusEditorId == richTextView.editorId)
+
+    private fun clearPendingNativeActionRetryIfScopeChanged() {
+        val action = pendingNativeAction ?: return
+        val scope = pendingNativeActionScope ?: return
+        if (!isPendingNativeActionScopeCurrent(action, scope)) {
+            clearPendingNativeActionRetry()
+        }
+    }
+
+    private fun schedulePendingNativeActionRetry(action: PendingNativeAction) {
+        val isSameAction = pendingNativeAction == action
+        if (isSameAction) {
+            pendingNativeActionRetryAttempts += 1
+        } else {
+            pendingNativeActionRetryAttempts = 1
+            pendingNativeActionScope = currentNativeActionScope(action)
+        }
+        if (pendingNativeActionRetryAttempts > MAX_NATIVE_ACTION_RETRY_ATTEMPTS) {
+            pendingNativeAction = action
+            pendingNativeActionRetryEditorId = richTextView.editorId
+            pendingNativeActionRetryScheduled = false
+            return
+        }
+        pendingNativeAction = action
+        pendingNativeActionRetryEditorId = richTextView.editorId
+        if (pendingNativeActionRetryScheduled) return
+        pendingNativeActionRetryScheduled = true
+        pendingNativeActionRetryGeneration += 1
+        val retryGeneration = pendingNativeActionRetryGeneration
+        val retry = Runnable {
+            if (retryGeneration != pendingNativeActionRetryGeneration) return@Runnable
+            val retryAction = pendingNativeAction ?: run {
+                pendingNativeActionRetryScheduled = false
+                return@Runnable
+            }
+            val retryScope = pendingNativeActionScope ?: run {
+                clearPendingNativeActionRetry()
+                return@Runnable
+            }
+            if (pendingNativeActionRetryEditorId != richTextView.editorId || richTextView.editorId == 0L) {
+                clearPendingNativeActionRetry()
+                return@Runnable
+            }
+            if (!isPendingNativeActionScopeCurrent(retryAction, retryScope)) {
+                clearPendingNativeActionRetry()
+                return@Runnable
+            }
+            pendingNativeActionRetryScheduled = false
+            val allowNextRetry = pendingNativeActionRetryAttempts < MAX_NATIVE_ACTION_RETRY_ATTEMPTS
+            when (retryAction) {
+                is PendingNativeAction.ToolbarItemPress ->
+                    handleToolbarItemPress(retryAction.item, allowPreflightRetry = allowNextRetry)
+                is PendingNativeAction.MentionSuggestionSelect ->
+                    insertMentionSuggestion(retryAction.suggestion, allowPreflightRetry = allowNextRetry)
+            }
+        }
+        mainHandler.postDelayed(retry, NATIVE_ACTION_RETRY_DELAY_MS)
+    }
+
+    private fun retryPendingNativeActionFromWake() {
+        val action = pendingNativeAction ?: return
+        val scope = pendingNativeActionScope ?: run {
+            clearPendingNativeActionRetry()
+            return
+        }
+        if (!isPendingNativeActionScopeCurrent(action, scope)) {
+            clearPendingNativeActionRetry()
+            return
+        }
+        pendingNativeActionRetryAttempts = 0
+        pendingNativeActionRetryScheduled = false
+        when (action) {
+            is PendingNativeAction.ToolbarItemPress ->
+                handleToolbarItemPress(action.item, allowPreflightRetry = true)
+            is PendingNativeAction.MentionSuggestionSelect ->
+                insertMentionSuggestion(action.suggestion, allowPreflightRetry = true)
+        }
+    }
+
+    private fun documentVersionFromUpdateJSON(updateJSON: String?): Int? =
+        try {
+            if (updateJSON == null) null
+            else {
+                val version = JSONObject(updateJSON).optInt("documentVersion", Int.MIN_VALUE)
+                version.takeIf { it != Int.MIN_VALUE }
+            }
+        } catch (_: Throwable) {
+            null
+        }
+
+    private fun noteDocumentVersionFromUpdateJSON(updateJSON: String?) {
+        documentVersionFromUpdateJSON(updateJSON)?.let { version ->
+            lastDocumentVersion = version
+        }
+    }
+
+    private fun addPreflightUpdateToEvent(
+        event: MutableMap<String, Any>,
+        updateJSON: String?
+    ) {
+        if (updateJSON == null) return
+        event["updateJson"] = updateJSON
+        documentVersionFromUpdateJSON(updateJSON)?.let { version ->
+            event["documentVersion"] = version
+        }
+    }
+
+    private fun emitAddonEvent(payload: Map<String, Any>) {
+        onAddonEventForTesting?.invoke(payload) ?: onAddonEvent(payload)
+    }
+
+    private fun canFocusCurrentEditor(): Boolean {
+        val editorId = richTextView.editorId
+        return editorId != 0L &&
+            isAttachedToNativeWindow &&
+            !NativeEditorViewRegistry.isDestroyed(editorId)
     }
 
     fun focus() {
+        if (!canFocusCurrentEditor()) return
         cancelPendingOutsideTapBlur()
         cancelPendingKeyboardDismiss()
+        cancelPendingBlurRetry()
         richTextView.editorEditText.requestFocus()
         richTextView.editorEditText.post {
+            if (!canFocusCurrentEditor()) return@post
             val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
             imm?.showSoftInput(richTextView.editorEditText, InputMethodManager.SHOW_IMPLICIT)
         }
@@ -293,24 +1285,96 @@ class NativeEditorExpoView(
         cancelPendingOutsideTapBlur()
         cancelPendingKeyboardDismiss()
         clearRecentToolbarTouch()
+        performBlur(deferKeyboardDismiss = false, allowRetry = true)
+    }
+
+    private fun performBlur(deferKeyboardDismiss: Boolean, allowRetry: Boolean) {
+        if (handleDestroyedCurrentEditorIfNeeded()) return
+        if (!richTextView.editorEditText.prepareForExternalEditorUpdate()) {
+            if (allowRetry && pendingBlurRetryAttempts < MAX_PENDING_UPDATE_RETRY_ATTEMPTS) {
+                schedulePendingBlurRetry(deferKeyboardDismiss)
+                return
+            }
+            if (handleDestroyedCurrentEditorIfNeeded()) return
+            richTextView.editorEditText.restoreAuthorizedTextIfNeeded()
+        }
+        completeBlur(deferKeyboardDismiss)
+    }
+
+    private fun completeBlur(deferKeyboardDismiss: Boolean) {
+        cancelPendingBlurRetry()
         richTextView.editorEditText.clearFocus()
+        if (deferKeyboardDismiss) {
+            val dismiss = Runnable {
+                pendingKeyboardDismiss = null
+                if (!richTextView.editorEditText.hasFocus()) {
+                    val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
+                    imm?.hideSoftInputFromWindow(richTextView.editorEditText.windowToken, 0)
+                }
+            }
+            pendingKeyboardDismiss = dismiss
+            richTextView.editorEditText.post(dismiss)
+            return
+        }
         val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
         imm?.hideSoftInputFromWindow(richTextView.editorEditText.windowToken, 0)
     }
 
+    private fun schedulePendingBlurRetry(deferKeyboardDismiss: Boolean) {
+        pendingBlurRetry?.let {
+            mainHandler.removeCallbacks(it)
+            pendingBlurRetry = null
+        }
+        pendingBlurRetryAttempts += 1
+        pendingBlurRetryEditorId = richTextView.editorId
+        pendingBlurRetryGeneration += 1
+        val retryGeneration = pendingBlurRetryGeneration
+        val delayMs = NATIVE_ACTION_RETRY_DELAY_MS * pendingBlurRetryAttempts
+        val retry = Runnable {
+            pendingBlurRetry = null
+            if (retryGeneration != pendingBlurRetryGeneration) return@Runnable
+            if (pendingBlurRetryEditorId != richTextView.editorId) {
+                pendingBlurRetryEditorId = null
+                return@Runnable
+            }
+            pendingBlurRetryEditorId = null
+            if (handleDestroyedCurrentEditorIfNeeded()) return@Runnable
+            performBlur(deferKeyboardDismiss, allowRetry = true)
+        }
+        pendingBlurRetry = retry
+        mainHandler.postDelayed(retry, delayMs)
+    }
+
     private fun blurWithDeferredKeyboardDismiss() {
         cancelPendingKeyboardDismiss()
         clearRecentToolbarTouch()
-        richTextView.editorEditText.clearFocus()
-        val dismiss = Runnable {
-            pendingKeyboardDismiss = null
-            if (!richTextView.editorEditText.hasFocus()) {
-                val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
-                imm?.hideSoftInputFromWindow(richTextView.editorEditText.windowToken, 0)
-            }
+        performBlur(deferKeyboardDismiss = true, allowRetry = true)
+    }
+
+    private fun scheduleToolbarRefocus() {
+        cancelPendingToolbarRefocus()
+        val editorId = richTextView.editorId
+        pendingToolbarRefocusEditorId = editorId
+        pendingToolbarRefocusGeneration += 1
+        val refocusGeneration = pendingToolbarRefocusGeneration
+        val refocus = Runnable {
+            pendingToolbarRefocus = null
+            if (refocusGeneration != pendingToolbarRefocusGeneration) return@Runnable
+            if (pendingToolbarRefocusEditorId != richTextView.editorId) return@Runnable
+            pendingToolbarRefocusEditorId = null
+            focus()
+        }
+        pendingToolbarRefocus = refocus
+        richTextView.editorEditText.post(refocus)
+    }
+
+    private fun cancelPendingToolbarRefocus() {
+        pendingToolbarRefocus?.let {
+            richTextView.editorEditText.removeCallbacks(it)
+            pendingToolbarRefocus = null
         }
-        pendingKeyboardDismiss = dismiss
-        richTextView.editorEditText.post(dismiss)
+        pendingToolbarRefocusEditorId = null
+        pendingToolbarRefocusGeneration += 1
     }
 
     private fun scheduleOutsideTapBlur() {
@@ -339,6 +1403,16 @@ class NativeEditorExpoView(
         }
     }
 
+    private fun cancelPendingBlurRetry() {
+        pendingBlurRetry?.let {
+            mainHandler.removeCallbacks(it)
+            pendingBlurRetry = null
+        }
+        pendingBlurRetryEditorId = null
+        pendingBlurRetryAttempts = 0
+        pendingBlurRetryGeneration += 1
+    }
+
     fun getCaretRectJson(): String? {
         if (width <= 0 || height <= 0) return null
         val rect = richTextView.caretRect() ?: return null
@@ -353,12 +1427,182 @@ class NativeEditorExpoView(
             .toString()
     }
 
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        handleAttachedToWindow()
+    }
+
+    internal fun handleEditorDestroyed(editorId: Long) {
+        if (richTextView.editorId != editorId && richTextView.editorEditText.editorId != editorId) {
+            return
+        }
+        cancelPendingEditorUpdateRetry()
+        clearPendingViewCommandUpdateRetry()
+        cancelPendingThemeRetry()
+        cancelPendingBlurRetry()
+        cancelPendingDetachPreflightRetry()
+        cancelPendingOutsideTapBlur()
+        cancelPendingKeyboardDismiss()
+        cancelPendingToolbarRefocus()
+        cancelPendingPreflightWake()
+        clearPendingNativeActionRetry()
+        clearRecentToolbarTouch()
+        uninstallOutsideTapBlurHandler()
+        detachKeyboardToolbarIfNeeded()
+        richTextView.setViewportBottomInsetPx(0)
+        val editText = richTextView.editorEditText
+        if (editText.hasFocus()) {
+            editText.clearFocus()
+        }
+        val imm = context.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
+        imm?.hideSoftInputFromWindow(editText.windowToken, 0)
+        clearMentionQueryState(resetLastEvent = true)
+        pendingEditorUpdateJson = null
+        pendingEditorUpdateEditorId = null
+        pendingEditorUpdateRevision = 0
+        appliedEditorUpdateRevision = 0
+        lastDocumentVersion = null
+        lastReadyEditorId = null
+        toolbarState = NativeToolbarState.empty
+        keyboardToolbarView.applyState(toolbarState)
+        keyboardToolbarView.visibility = View.GONE
+        richTextView.editorId = 0L
+    }
+
+    private fun handleDestroyedCurrentEditorIfNeeded(): Boolean {
+        val editorId = richTextView.editorId.takeIf { it != 0L }
+            ?: richTextView.editorEditText.editorId.takeIf { it != 0L }
+            ?: return false
+        if (!NativeEditorViewRegistry.isDestroyed(editorId)) return false
+        handleEditorDestroyed(editorId)
+        return true
+    }
+
+    private fun handleAttachedToWindow() {
+        isAttachedToNativeWindow = true
+        cancelPendingDetachPreflightRetry()
+        richTextView.clearDeferredEditorUnbind()
+        val editorId = richTextView.editorId
+        if (editorId == 0L) return
+        if (NativeEditorViewRegistry.isDestroyed(editorId)) {
+            handleEditorDestroyed(editorId)
+            return
+        }
+        if (!NativeEditorViewRegistry.register(editorId, this)) {
+            handleEditorDestroyed(editorId)
+            return
+        }
+        richTextView.rebindEditorIfNeeded(
+            notifyListener = !hasPendingEditorUpdateForEditor(editorId)
+        )
+        if (hasPendingTheme) {
+            pendingThemeRetryEditorId = editorId
+        }
+        applyPendingEditorUpdateIfNeeded()
+        applyPendingThemeIfNeeded()
+        refreshReadyStateIfSettled()
+        applyAutoFocusIfNeeded()
+    }
+
+    private fun emitEditorReady(editorUpdateRevision: Int? = null): Boolean {
+        val editorId = richTextView.editorId
+        if (editorId == 0L) return false
+        if (!isAttachedToNativeWindow) return false
+        if (richTextView.editorEditText.editorId != editorId) return false
+        if (hasPendingEditorUpdateForCurrentEditor()) return false
+        lastReadyEditorId = editorId
+        val payload = mutableMapOf<String, Any>("editorId" to editorId)
+        editorUpdateRevision?.let { payload["editorUpdateRevision"] = it }
+        onEditorReadyForTesting?.invoke(payload) ?: onEditorReady(payload)
+        return true
+    }
+
+    private fun emitEditorReadyIfNeeded() {
+        val editorId = richTextView.editorId
+        if (lastReadyEditorId == editorId) return
+        emitEditorReady()
+    }
+
     override fun onDetachedFromWindow() {
+        prepareForDetachFromWindow()
         super.onDetachedFromWindow()
+        handleDetachedFromWindow()
+    }
+
+    private fun prepareForDetachFromWindow() {
+        if (handleDestroyedCurrentEditorIfNeeded()) return
+        val editorId = richTextView.editorId
+        if (editorId == 0L || richTextView.editorEditText.editorId == 0L) return
+        if (richTextView.editorEditText.prepareForExternalEditorUpdate()) {
+            cancelPendingDetachPreflightRetry()
+            richTextView.clearDeferredEditorUnbind()
+            return
+        }
+        richTextView.deferEditorUnbindOnNextDetach()
+        schedulePendingDetachPreflightRetry(editorId)
+    }
+
+    private fun schedulePendingDetachPreflightRetry(editorId: Long) {
+        if (pendingDetachPreflightRetryScheduled) return
+        if (pendingDetachPreflightRetryAttempts >= MAX_PENDING_UPDATE_RETRY_ATTEMPTS) {
+            if (handleDestroyedCurrentEditorIfNeeded()) return
+            richTextView.editorEditText.restoreAuthorizedTextIfNeeded()
+            cancelPendingDetachPreflightRetry()
+            richTextView.unbindEditorForDetachedViewIfNeeded()
+            return
+        }
+        pendingDetachPreflightRetryAttempts += 1
+        pendingDetachPreflightRetryEditorId = editorId
+        pendingDetachPreflightRetryScheduled = true
+        pendingDetachPreflightRetryGeneration += 1
+        val retryGeneration = pendingDetachPreflightRetryGeneration
+        val delayMs = NATIVE_ACTION_RETRY_DELAY_MS * pendingDetachPreflightRetryAttempts
+        mainHandler.postDelayed({
+            if (retryGeneration != pendingDetachPreflightRetryGeneration) return@postDelayed
+            pendingDetachPreflightRetryScheduled = false
+            if (isAttachedToNativeWindow || pendingDetachPreflightRetryEditorId != richTextView.editorId) {
+                cancelPendingDetachPreflightRetry()
+                return@postDelayed
+            }
+            if (handleDestroyedCurrentEditorIfNeeded()) return@postDelayed
+            if (richTextView.editorEditText.prepareForExternalEditorUpdate()) {
+                cancelPendingDetachPreflightRetry()
+                richTextView.unbindEditorForDetachedViewIfNeeded()
+                return@postDelayed
+            }
+            schedulePendingDetachPreflightRetry(editorId)
+        }, delayMs)
+    }
+
+    private fun cancelPendingDetachPreflightRetry() {
+        pendingDetachPreflightRetryScheduled = false
+        pendingDetachPreflightRetryEditorId = null
+        pendingDetachPreflightRetryAttempts = 0
+        pendingDetachPreflightRetryGeneration += 1
+    }
+
+    private fun handleDetachedFromWindow() {
+        isAttachedToNativeWindow = false
+        NativeEditorViewRegistry.unregister(
+            richTextView.editorId,
+            this,
+            blockCommandsUntilRegistered = true
+        )
         cancelPendingOutsideTapBlur()
         cancelPendingKeyboardDismiss()
+        cancelPendingToolbarRefocus()
+        cancelPendingBlurRetry()
+        cancelPendingEditorUpdateRetry()
+        clearPendingViewCommandUpdateRetry()
+        cancelPendingThemeRetry()
+        clearPendingNativeActionRetry()
+        cancelPendingPreflightWake()
+        lastReadyEditorId = null
         uninstallOutsideTapBlurHandler()
+        currentImeBottom = 0
+        keyboardToolbarView.visibility = View.GONE
         detachKeyboardToolbarIfNeeded()
+        richTextView.setViewportBottomInsetPx(0)
     }
 
     override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
@@ -436,30 +1680,131 @@ class NativeEditorExpoView(
         if (contentHeight <= 0) return
         if (!force && contentHeight == lastEmittedContentHeight) return
         lastEmittedContentHeight = contentHeight
-        onContentHeightChange(mapOf("contentHeight" to contentHeight))
+        onContentHeightChange(
+            mapOf(
+                "contentHeight" to contentHeight,
+                "editorId" to richTextView.editorId
+            )
+        )
     }
 
     /** Applies an editor update from JS without echoing it back through events. */
-    fun applyEditorUpdate(updateJson: String) {
-        val apply = Runnable {
-            isApplyingJSUpdate = true
-            richTextView.editorEditText.applyUpdateJSON(updateJson)
-            isApplyingJSUpdate = false
-        }
-        if (android.os.Looper.myLooper() == android.os.Looper.getMainLooper()) {
-            apply.run()
-        } else {
+    fun applyEditorUpdate(updateJson: String): Boolean =
+        applyEditorUpdate(updateJson, scheduleViewCommandRetry = true)
+
+    private fun isEditorReadyForNativeUpdate(): Boolean {
+        val editorId = richTextView.editorId
+        return editorId == 0L || (isAttachedToNativeWindow && richTextView.editorEditText.editorId == editorId)
+    }
+
+    private fun applyEditorUpdate(
+        updateJson: String,
+        scheduleViewCommandRetry: Boolean,
+        expectedEditorId: Long? = null
+    ): Boolean {
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            val postedEditorId = expectedEditorId ?: richTextView.editorId
+            val apply = Runnable {
+                if (postedEditorId != richTextView.editorId) return@Runnable
+                applyEditorUpdate(updateJson, scheduleViewCommandRetry, postedEditorId)
+            }
             if (!post(apply)) {
                 richTextView.post(apply)
             }
+            return false
+        }
+        if (expectedEditorId != null && expectedEditorId != richTextView.editorId) {
+            return false
+        }
+        if (handleDestroyedCurrentEditorIfNeeded()) {
+            return false
+        }
+        if (!isEditorReadyForNativeUpdate()) {
+            if (scheduleViewCommandRetry) {
+                scheduleViewCommandUpdateRetry(updateJson)
+            }
+            return false
+        }
+        if (
+            blockEditorUpdatePreflightForTesting ||
+            !richTextView.editorEditText.prepareForExternalEditorUpdate()
+        ) {
+            if (scheduleViewCommandRetry) {
+                scheduleViewCommandUpdateRetry(updateJson)
+            }
+            return false
+        }
+        isApplyingJSUpdate = true
+        return try {
+            richTextView.editorEditText.applyUpdateJSON(updateJson)
+            true
+        } catch (error: Throwable) {
+            Log.w(LOG_TAG, "Failed to apply JS editor update", error)
+            if (scheduleViewCommandRetry) {
+                scheduleViewCommandUpdateRetry(updateJson)
+            }
+            false
+        } finally {
+            isApplyingJSUpdate = false
+        }
+    }
+
+    fun prepareForEditorCommandJSON(): String {
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            return NativeEditorViewRegistry.commandPreparationJSON(
+                ready = false,
+                blockedReason = "unknown"
+            )
+        }
+        if (handleDestroyedCurrentEditorIfNeeded()) {
+            return NativeEditorViewRegistry.commandPreparationJSON(
+                ready = false,
+                blockedReason = "destroyed"
+            )
+        }
+        if (richTextView.editorId != 0L && !isAttachedToNativeWindow) {
+            return NativeEditorViewRegistry.commandPreparationJSON(
+                ready = false,
+                blockedReason = "detached"
+            )
+        }
+        if (richTextView.editorId != 0L && richTextView.editorEditText.editorId != richTextView.editorId) {
+            return NativeEditorViewRegistry.commandPreparationJSON(
+                ready = false,
+                blockedReason = "detached"
+            )
+        }
+        if (shouldBlockEditorCommandForPendingUpdate()) {
+            return pendingEditorUpdateCommandPreparationJSON()
+        }
+        isApplyingJSUpdate = true
+        return try {
+            onBeforePrepareForEditorCommandForTesting?.invoke()
+            val preparation = richTextView.editorEditText.prepareForExternalEditorCommand()
+            NativeEditorViewRegistry.commandPreparationJSON(
+                ready = preparation.ready,
+                updateJSON = preparation.updateJSON,
+                blockedReason = if (preparation.ready) null else "composition"
+            )
+        } finally {
+            isApplyingJSUpdate = false
         }
     }
 
     override fun onSelectionChanged(anchor: Int, head: Int) {
         val stateJson = refreshToolbarStateFromEditorSelection()
         refreshMentionQuery()
+        clearPendingNativeActionRetryIfScopeChanged()
+        schedulePendingPreflightWake()
         richTextView.refreshRemoteSelections()
-        val event = mutableMapOf<String, Any>("anchor" to anchor, "head" to head)
+        val event = mutableMapOf<String, Any>(
+            "anchor" to anchor,
+            "head" to head,
+            "editorId" to richTextView.editorId
+        )
+        lastDocumentVersion?.let {
+            event["documentVersion"] = it
+        }
         if (stateJson != null) {
             event["stateJson"] = stateJson
         }
@@ -467,11 +1812,14 @@ class NativeEditorExpoView(
     }
 
     override fun onEditorUpdate(updateJSON: String) {
+        noteDocumentVersionFromUpdateJSON(updateJSON)
         NativeToolbarState.fromUpdateJson(updateJSON)?.let { state ->
             toolbarState = state
             keyboardToolbarView.applyState(state)
         }
         refreshMentionQuery()
+        clearPendingNativeActionRetryIfScopeChanged()
+        schedulePendingPreflightWake()
         richTextView.refreshRemoteSelections()
         if (heightBehavior == EditorHeightBehavior.AUTO_GROW) {
             post {
@@ -480,44 +1828,39 @@ class NativeEditorExpoView(
             }
         }
         if (isApplyingJSUpdate) return
-        val event = mapOf<String, Any>("updateJson" to updateJSON)
+        val event = mapOf<String, Any>(
+            "updateJson" to updateJSON,
+            "editorId" to richTextView.editorId
+        )
         onEditorUpdate(event)
     }
 
     private fun installOutsideTapBlurHandlerIfNeeded() {
         val window = resolveActivity(context)?.window ?: return
-        val currentCallback = window.callback ?: return
-        if (currentCallback === outsideTapWindowCallback) return
-
-        val wrappedCallback = object : Window.Callback by currentCallback {
-            override fun dispatchTouchEvent(event: MotionEvent): Boolean {
-                val shouldBlur =
-                    event.action == MotionEvent.ACTION_DOWN &&
-                    richTextView.editorEditText.hasFocus() &&
-                    isTouchOutsideEditor(event)
-                val result = currentCallback.dispatchTouchEvent(event)
-                if (shouldBlur) {
-                    scheduleOutsideTapBlur()
-                } else if (event.action == MotionEvent.ACTION_DOWN) {
-                    cancelPendingOutsideTapBlur()
-                }
-                return result
-            }
-        }
-
-        previousWindowCallback = currentCallback
-        outsideTapWindowCallback = wrappedCallback
-        window.callback = wrappedCallback
+        if (outsideTapWindow === window) return
+        uninstallOutsideTapBlurHandler()
+        NativeEditorOutsideTapDispatcher.register(window, this)
+        outsideTapWindow = window
     }
 
     private fun uninstallOutsideTapBlurHandler() {
-        val window = resolveActivity(context)?.window ?: return
-        val callback = outsideTapWindowCallback ?: return
-        if (window.callback === callback) {
-            window.callback = previousWindowCallback ?: callback
-        }
-        outsideTapWindowCallback = null
-        previousWindowCallback = null
+        val window = outsideTapWindow ?: return
+        NativeEditorOutsideTapDispatcher.unregister(window, this)
+        outsideTapWindow = null
+    }
+
+    internal fun shouldScheduleOutsideTapBlurForWindowEvent(event: MotionEvent): Boolean =
+        isAttachedToNativeWindow &&
+            event.action == MotionEvent.ACTION_DOWN &&
+            richTextView.editorEditText.hasFocus() &&
+            isTouchOutsideEditor(event)
+
+    internal fun scheduleOutsideTapBlurFromWindowDispatcher() {
+        scheduleOutsideTapBlur()
+    }
+
+    internal fun cancelOutsideTapBlurFromWindowDispatcher() {
+        cancelPendingOutsideTapBlur()
     }
 
     private fun isTouchOutsideEditor(event: MotionEvent): Boolean {
@@ -555,6 +1898,125 @@ class NativeEditorExpoView(
     internal fun shouldPreserveFocusAfterToolbarTouchForTesting(): Boolean =
         shouldPreserveFocusAfterToolbarTouch()
 
+    internal fun setAttachedToNativeWindowForTesting(isAttached: Boolean) {
+        isAttachedToNativeWindow = isAttached
+    }
+
+    internal fun handleAttachedToWindowForTesting() {
+        handleAttachedToWindow()
+    }
+
+    internal fun handleDetachedFromWindowForTesting() {
+        prepareForDetachFromWindow()
+        handleDetachedFromWindow()
+    }
+
+    internal fun performBlurForTesting(deferKeyboardDismiss: Boolean = false) {
+        performBlur(deferKeyboardDismiss = deferKeyboardDismiss, allowRetry = true)
+    }
+
+    internal fun pendingBlurRetryAttemptsForTesting(): Int = pendingBlurRetryAttempts
+
+    internal fun pendingDetachPreflightRetryAttemptsForTesting(): Int =
+        pendingDetachPreflightRetryAttempts
+
+    internal fun hasPendingOutsideTapBlurForTesting(): Boolean = pendingOutsideTapBlur != null
+
+    internal fun hasPendingKeyboardDismissForTesting(): Boolean = pendingKeyboardDismiss != null
+
+    internal fun hasPendingPreflightWakeForTesting(): Boolean = pendingPreflightWakeScheduled
+
+    internal fun hasPendingToolbarRefocusForTesting(): Boolean = pendingToolbarRefocus != null
+
+    internal fun isKeyboardToolbarAttachedForTesting(): Boolean = keyboardToolbarView.parent != null
+
+    internal fun currentImeBottomForTesting(): Int = currentImeBottom
+
+    internal fun setCurrentImeBottomForTesting(bottom: Int) {
+        currentImeBottom = bottom
+    }
+
+    internal fun updateAttachedKeyboardToolbarForInsetsForTesting() {
+        updateAttachedKeyboardToolbarForInsets()
+    }
+
+    internal fun scheduleToolbarRefocusForTesting() {
+        scheduleToolbarRefocus()
+    }
+
+    internal fun applyAutoFocusForTesting() {
+        applyAutoFocusIfNeeded()
+    }
+
+    internal fun installOutsideTapBlurHandlerForTesting() {
+        installOutsideTapBlurHandlerIfNeeded()
+    }
+
+    internal fun uninstallOutsideTapBlurHandlerForTesting() {
+        uninstallOutsideTapBlurHandler()
+    }
+
+    internal fun schedulePendingPreflightWakeForTesting() {
+        schedulePendingPreflightWake()
+    }
+
+    internal fun hasPendingNativeActionForTesting(): Boolean = pendingNativeAction != null
+
+    internal fun pendingNativeActionRetryAttemptsForTesting(): Int = pendingNativeActionRetryAttempts
+
+    internal fun lastDocumentVersionForTesting(): Int? = lastDocumentVersion
+
+    internal fun setLastDocumentVersionForTesting(documentVersion: Int?) {
+        lastDocumentVersion = documentVersion
+    }
+
+    internal fun refreshToolbarStateFromEditorSelectionForTesting(): String? =
+        refreshToolbarStateFromEditorSelection()
+
+    internal fun handleToolbarItemPressForTesting(item: NativeToolbarItem) {
+        handleToolbarItemPress(item)
+    }
+
+    internal fun insertMentionSuggestionForTesting(suggestion: NativeMentionSuggestion) {
+        insertMentionSuggestion(suggestion)
+    }
+
+    internal fun wakePendingPreflightWorkForTesting() {
+        wakePendingPreflightWork()
+    }
+
+    internal fun emitEditorReadyForTesting(editorUpdateRevision: Int? = null): Boolean =
+        emitEditorReady(editorUpdateRevision)
+
+    internal fun pendingEditorUpdateJsonForTesting(): String? = pendingEditorUpdateJson
+
+    internal fun pendingEditorUpdateRevisionForTesting(): Int = pendingEditorUpdateRevision
+
+    internal fun setAppliedEditorUpdateRevisionForTesting(editorUpdateRevision: Int) {
+        appliedEditorUpdateRevision = editorUpdateRevision
+    }
+
+    internal fun pendingEditorUpdateEditorIdForTesting(): Long? = pendingEditorUpdateEditorId
+
+    internal fun pendingViewCommandUpdateJsonForTesting(): String? = pendingViewCommandUpdateJson
+
+    internal fun pendingViewCommandUpdateRetryAttemptsForTesting(): Int =
+        pendingViewCommandUpdateRetryAttempts
+
+    internal fun scheduleViewCommandUpdateRetryForTesting(updateJson: String) {
+        scheduleViewCommandUpdateRetry(updateJson)
+    }
+
+    internal fun pendingThemeJsonForTesting(): String? = pendingThemeJson.takeIf { hasPendingTheme }
+
+    internal fun lastThemeJsonForTesting(): String? = lastThemeJson
+
+    internal fun pendingThemeRetryAttemptsForTesting(): Int = pendingThemeRetryAttempts
+
+    internal fun applyPendingThemeForTesting() {
+        applyPendingThemeIfNeeded()
+    }
+
     private fun isTouchInsideStandaloneToolbar(event: MotionEvent): Boolean {
         val visibleWindowFrame = Rect()
         getWindowVisibleDisplayFrame(visibleWindowFrame)
@@ -619,6 +2081,11 @@ class NativeEditorExpoView(
         private const val TOOLBAR_HIT_SLOP_DP = 8f
         private const val TOOLBAR_FOCUS_PRESERVE_MS = 750L
         private const val OUTSIDE_TAP_BLUR_DELAY_MS = 100L
+        private const val NATIVE_ACTION_RETRY_DELAY_MS = 16L
+        private const val PENDING_UPDATE_RECOVERY_RETRY_DELAY_MS = 250L
+        private const val MAX_NATIVE_ACTION_RETRY_ATTEMPTS = 3
+        private const val MAX_PENDING_UPDATE_RETRY_ATTEMPTS = 5
+        private const val LOG_TAG = "NativeEditor"
     }
 
     private fun resolveActivity(context: Context): Activity? {
@@ -658,8 +2125,12 @@ class NativeEditorExpoView(
         )
     }
 
-    private fun clearMentionQueryState() {
+    private fun clearMentionQueryState(resetLastEvent: Boolean = false) {
         mentionQueryState = null
+        if (resetLastEvent) {
+            lastMentionEventJson = null
+            lastMentionEventEditorId = null
+        }
         syncKeyboardToolbarMentionSuggestions(emptyList())
     }
 
@@ -722,10 +2193,15 @@ class NativeEditorExpoView(
             .put("trigger", trigger)
             .put("range", JSONObject().put("anchor", anchor).put("head", head))
             .put("isActive", isActive)
+            .apply {
+                lastDocumentVersion?.let { put("documentVersion", it) }
+            }
             .toString()
-        if (eventJson == lastMentionEventJson) return
+        val editorId = richTextView.editorId
+        if (eventJson == lastMentionEventJson && editorId == lastMentionEventEditorId) return
         lastMentionEventJson = eventJson
-        onAddonEvent(mapOf("eventJson" to eventJson))
+        lastMentionEventEditorId = editorId
+        emitAddonEvent(mapOf("eventJson" to eventJson, "editorId" to editorId))
     }
 
     private fun resolvedMentionAttrs(
@@ -748,15 +2224,19 @@ class NativeEditorExpoView(
             .put("trigger", trigger)
             .put("suggestionKey", suggestion.key)
             .put("attrs", attrs)
+            .apply {
+                lastDocumentVersion?.let { put("documentVersion", it) }
+            }
             .toString()
-        onAddonEvent(mapOf("eventJson" to eventJson))
+        emitAddonEvent(mapOf("eventJson" to eventJson, "editorId" to richTextView.editorId))
     }
 
     private fun emitMentionSelectRequest(
         trigger: String,
         suggestion: NativeMentionSuggestion,
         attrs: JSONObject,
-        range: MentionQueryState
+        range: MentionQueryState,
+        preflightUpdateJSON: String?
     ) {
         val eventJson = JSONObject()
             .put("type", "mentionsSelectRequest")
@@ -764,16 +2244,60 @@ class NativeEditorExpoView(
             .put("suggestionKey", suggestion.key)
             .put("attrs", attrs)
             .put("range", JSONObject().put("anchor", range.anchor).put("head", range.head))
+            .apply {
+                if (preflightUpdateJSON != null) {
+                    put("updateJson", preflightUpdateJSON)
+                }
+                (documentVersionFromUpdateJSON(preflightUpdateJSON) ?: lastDocumentVersion)
+                    ?.let { put("documentVersion", it) }
+            }
             .toString()
-        onAddonEvent(mapOf("eventJson" to eventJson))
+        emitAddonEvent(mapOf("eventJson" to eventJson, "editorId" to richTextView.editorId))
     }
 
-    private fun insertMentionSuggestion(suggestion: NativeMentionSuggestion) {
+    private fun insertMentionSuggestion(
+        suggestion: NativeMentionSuggestion,
+        allowPreflightRetry: Boolean = true
+    ) {
+        if (handleDestroyedCurrentEditorIfNeeded()) return
+        if (!richTextView.editorEditText.isEditable) {
+            clearPendingNativeActionRetry()
+            return
+        }
         val mentions = addons.mentions ?: return
-        val queryState = mentionQueryState ?: return
+        if (shouldBlockEditorCommandForPendingUpdate()) {
+            if (allowPreflightRetry) {
+                schedulePendingNativeActionRetry(
+                    PendingNativeAction.MentionSuggestionSelect(suggestion)
+                )
+            }
+            return
+        }
+        val preparation = richTextView.editorEditText.prepareForExternalEditorCommand()
+        if (!preparation.ready) {
+            if (allowPreflightRetry) {
+                schedulePendingNativeActionRetry(
+                    PendingNativeAction.MentionSuggestionSelect(suggestion)
+                )
+            }
+            return
+        }
+        val preflightUpdateJSON = preparation.updateJSON
+        noteDocumentVersionFromUpdateJSON(preflightUpdateJSON)
+        clearPendingNativeActionRetry()
+        val queryState = currentMentionQueryState(mentions.trigger) ?: run {
+            clearMentionQueryState()
+            return
+        }
+        val freshSuggestions = filteredMentionSuggestions(queryState, mentions)
+        if (freshSuggestions.none { it.key == suggestion.key }) {
+            refreshMentionQuery()
+            return
+        }
+        mentionQueryState = queryState
         val attrs = resolvedMentionAttrs(mentions.trigger, suggestion)
         if (mentions.resolveSelectionAttrs || mentions.resolveTheme) {
-            emitMentionSelectRequest(mentions.trigger, suggestion, attrs, queryState)
+            emitMentionSelectRequest(mentions.trigger, suggestion, attrs, queryState, preflightUpdateJSON)
             lastMentionEventJson = null
             clearMentionQueryState()
             return
@@ -803,7 +2327,14 @@ class NativeEditorExpoView(
 
     private fun refreshToolbarStateFromEditorSelection(): String? {
         if (richTextView.editorId == 0L) return null
+        if (handleDestroyedCurrentEditorIfNeeded()) return null
+        onRefreshToolbarStateFromEditorSelectionForTesting?.let { callback ->
+            val stateJson = callback()
+            noteDocumentVersionFromUpdateJSON(stateJson)
+            return stateJson
+        }
         val stateJson = editorGetSelectionState(richTextView.editorId.toULong())
+        noteDocumentVersionFromUpdateJSON(stateJson)
         val state = NativeToolbarState.fromUpdateJson(stateJson) ?: return null
         toolbarState = state
         keyboardToolbarView.applyState(state)
@@ -847,6 +2378,9 @@ class NativeEditorExpoView(
     }
 
     private fun updateAttachedKeyboardToolbarForInsets() {
+        if (currentImeBottom <= 0) {
+            clearPendingNativeActionRetry()
+        }
         keyboardToolbarView.visibility = if (currentImeBottom > 0) View.VISIBLE else View.INVISIBLE
         updateEditorViewportInset()
     }
@@ -854,6 +2388,7 @@ class NativeEditorExpoView(
     private fun updateKeyboardToolbarVisibility() {
         val shouldAttach =
             showsToolbar &&
+                canFocusCurrentEditor() &&
                 toolbarPlacement == ToolbarPlacement.KEYBOARD &&
                 richTextView.editorEditText.isEditable &&
                 richTextView.editorEditText.hasFocus()
@@ -870,7 +2405,7 @@ class NativeEditorExpoView(
         updateEditorViewportInset()
     }
 
-    private fun updateEditorViewportInset() {
+    private fun updateEditorViewportInset(forceMeasureToolbar: Boolean = false) {
         val shouldReserveToolbarSpace =
             heightBehavior == EditorHeightBehavior.FIXED &&
                 showsToolbar &&
@@ -889,7 +2424,7 @@ class NativeEditorExpoView(
         val toolbarTheme = richTextView.editorEditText.theme?.toolbar
         val density = resources.displayMetrics.density
         val horizontalInsetPx = ((toolbarTheme?.resolvedHorizontalInset() ?: 0f) * density).toInt()
-        if (keyboardToolbarView.measuredHeight == 0) {
+        if (forceMeasureToolbar || keyboardToolbarView.measuredHeight == 0) {
             val availableWidth = (hostWidth - horizontalInsetPx * 2).coerceAtLeast(0)
             val widthSpec = MeasureSpec.makeMeasureSpec(availableWidth, MeasureSpec.AT_MOST)
             val heightSpec = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED)
@@ -904,7 +2439,46 @@ class NativeEditorExpoView(
         richTextView.editorEditText.performToolbarToggleList(listType, isActive)
     }
 
-    private fun handleToolbarItemPress(item: NativeToolbarItem) {
+    private fun handleToolbarItemPress(
+        item: NativeToolbarItem,
+        allowPreflightRetry: Boolean = true
+    ) {
+        if (handleDestroyedCurrentEditorIfNeeded()) return
+        if (!richTextView.editorEditText.isEditable) {
+            clearPendingNativeActionRetry()
+            return
+        }
+        var preflightUpdateJSON: String? = null
+        val needsEditorPreflight = when (item.type) {
+            ToolbarItemKind.mark,
+            ToolbarItemKind.heading,
+            ToolbarItemKind.blockquote,
+            ToolbarItemKind.list,
+            ToolbarItemKind.command,
+            ToolbarItemKind.node,
+            ToolbarItemKind.action -> true
+            ToolbarItemKind.group,
+            ToolbarItemKind.separator -> false
+        }
+        if (needsEditorPreflight) {
+            if (shouldBlockEditorCommandForPendingUpdate()) {
+                if (allowPreflightRetry) {
+                    schedulePendingNativeActionRetry(PendingNativeAction.ToolbarItemPress(item))
+                }
+                return
+            }
+            val preparation = richTextView.editorEditText.prepareForExternalEditorCommand()
+            if (!preparation.ready) {
+                if (allowPreflightRetry) {
+                    schedulePendingNativeActionRetry(PendingNativeAction.ToolbarItemPress(item))
+                }
+                return
+            }
+            preflightUpdateJSON = preparation.updateJSON
+            noteDocumentVersionFromUpdateJSON(preflightUpdateJSON)
+            clearPendingNativeActionRetry()
+        }
+        if (handleDestroyedCurrentEditorIfNeeded()) return
         when (item.type) {
             ToolbarItemKind.mark -> item.mark?.let { richTextView.editorEditText.performToolbarToggleMark(it) }
             ToolbarItemKind.heading -> item.headingLevel?.let { richTextView.editorEditText.performToolbarToggleHeading(it) }
@@ -918,7 +2492,20 @@ class NativeEditorExpoView(
                 null -> Unit
             }
             ToolbarItemKind.node -> item.nodeType?.let { richTextView.editorEditText.performToolbarInsertNode(it) }
-            ToolbarItemKind.action -> item.key?.let { onToolbarAction(mapOf("key" to it)) }
+            ToolbarItemKind.action -> item.key?.let {
+                if (handleDestroyedCurrentEditorIfNeeded()) return
+                val payload = mutableMapOf<String, Any>(
+                    "key" to it,
+                    "editorId" to richTextView.editorId
+                )
+                addPreflightUpdateToEvent(payload, preflightUpdateJSON)
+                if (!payload.containsKey("documentVersion")) {
+                    lastDocumentVersion?.let { version ->
+                        payload["documentVersion"] = version
+                    }
+                }
+                onToolbarActionForTesting?.invoke(payload) ?: onToolbarAction(payload)
+            }
             ToolbarItemKind.group -> Unit
             ToolbarItemKind.separator -> Unit
         }