@apollohg/react-native-prose-editor 0.5.8 → 0.5.10

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

@@ -38,9 +38,9 @@ import uniffi.editor_core.*  // UniFFI-generated bindings
  *
  * ## Composition Handling
  *
- * For CJK input methods, composing text is handled normally by the base
- * [InputConnection]. When composition finalizes, we capture the result and
- * route it through Rust.
+ * For CJK input methods, swipe keyboards, and some autocorrect flows, composing
+ * text is rendered transiently by the base [InputConnection]. The final commit
+ * is routed through Rust against the original authorized selection.
  *
  * ## Thread Safety
  *
@@ -190,6 +190,8 @@ class EditorEditText @JvmOverloads constructor(
     private var lastAppliedRenderAppearanceRevision: Long = 0L
     internal var onDeleteRangeInRustForTesting: ((Int, Int) -> Unit)? = null
     internal var onDeleteBackwardAtSelectionScalarInRustForTesting: ((Int, Int) -> Unit)? = null
+    internal var onInsertTextInRustForTesting: ((String, Int) -> Unit)? = null
+    internal var onReplaceTextInRustForTesting: ((Int, Int, String) -> Unit)? = null
 
     fun lastRenderAppliedPatch(): Boolean = lastRenderAppliedPatchForTesting
     fun lastApplyUpdateTrace(): ApplyUpdateTrace? = lastApplyUpdateTraceForTesting
@@ -583,16 +585,48 @@ class EditorEditText @JvmOverloads constructor(
             // Range selection: atomic replace via Rust.
             val scalarStart = PositionBridge.utf16ToScalar(start, currentText)
             val scalarEnd = PositionBridge.utf16ToScalar(end, currentText)
-            val updateJSON = editorReplaceTextScalar(
-                editorId.toULong(), scalarStart.toUInt(), scalarEnd.toUInt(), text
-            )
-            applyUpdateJSON(updateJSON)
+            replaceTextRangeInRust(scalarStart, scalarEnd, text)
         } else {
             val scalarPos = PositionBridge.utf16ToScalar(start, currentText)
             insertTextInRust(text, scalarPos)
         }
     }
 
+    internal fun runWithTransientInputMutationGuard(block: () -> Boolean): Boolean {
+        val wasApplyingRustState = isApplyingRustState
+        isApplyingRustState = true
+        return try {
+            block()
+        } finally {
+            isApplyingRustState = wasApplyingRustState
+        }
+    }
+
+    fun handleCompositionCommit(text: String, replacementStartUtf16: Int, replacementEndUtf16: Int) {
+        if (!isEditable) return
+        if (isApplyingRustState) return
+        if (editorId == 0L) return
+
+        if (text == "\n") {
+            handleReturnKey()
+            return
+        }
+
+        val authorizedText = lastAuthorizedText
+        val startUtf16 = minOf(replacementStartUtf16, replacementEndUtf16)
+            .coerceIn(0, authorizedText.length)
+        val endUtf16 = maxOf(replacementStartUtf16, replacementEndUtf16)
+            .coerceIn(0, authorizedText.length)
+        val scalarStart = PositionBridge.utf16ToScalar(startUtf16, authorizedText)
+        val scalarEnd = PositionBridge.utf16ToScalar(endUtf16, authorizedText)
+
+        if (scalarStart != scalarEnd) {
+            replaceTextRangeInRust(scalarStart, scalarEnd, text)
+        } else {
+            insertTextInRust(text, scalarStart)
+        }
+    }
+
     // ── Input Handling: Deletion ────────────────────────────────────────
 
     /**
@@ -699,35 +733,6 @@ class EditorEditText @JvmOverloads constructor(
         }
     }
 
-    // ── Input Handling: Composition ─────────────────────────────────────
-
-    /**
-     * Handle finalization of IME composition (CJK input, swipe keyboard).
-     *
-     * Called by [EditorInputConnection.finishComposingText] after the base
-     * InputConnection has finalized the composing text.
-     */
-    /**
-     * Handle finalization of IME composition.
-     *
-     * @param composedText The finalized composed text captured from the InputConnection.
-     */
-    fun handleCompositionFinished(composedText: String?) {
-        if (!isEditable) return
-        if (isApplyingRustState) return
-        if (editorId == 0L) return
-        if (composedText.isNullOrEmpty()) return
-
-        // The cursor is at the end of the composed text. Calculate the insert
-        // position as cursor - composed_length (in scalar offsets).
-        val currentText = text?.toString() ?: ""
-        val cursorUtf16 = selectionStart
-        val cursorScalar = PositionBridge.utf16ToScalar(cursorUtf16, currentText)
-        val composedScalarLen = composedText.codePointCount(0, composedText.length)
-        val insertPos = if (cursorScalar >= composedScalarLen) cursorScalar - composedScalarLen else 0
-        insertTextInRust(composedText, insertPos)
-    }
-
     // ── Input Handling: Return Key ──────────────────────────────────────
 
     /**
@@ -1078,10 +1083,28 @@ class EditorEditText @JvmOverloads constructor(
      * Insert text at a scalar position via the Rust editor.
      */
     private fun insertTextInRust(text: String, atScalarPos: Int) {
+        onInsertTextInRustForTesting?.let { callback ->
+            callback(text, atScalarPos)
+            return
+        }
         val updateJSON = editorInsertTextScalar(editorId.toULong(), atScalarPos.toUInt(), text)
         applyUpdateJSON(updateJSON)
     }
 
+    private fun replaceTextRangeInRust(scalarFrom: Int, scalarTo: Int, text: String) {
+        onReplaceTextInRustForTesting?.let { callback ->
+            callback(scalarFrom, scalarTo, text)
+            return
+        }
+        val updateJSON = editorReplaceTextScalar(
+            editorId.toULong(),
+            scalarFrom.toUInt(),
+            scalarTo.toUInt(),
+            text
+        )
+        applyUpdateJSON(updateJSON)
+    }
+
     /**
      * Delete a scalar range via the Rust editor.
      *

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

@@ -1,6 +1,7 @@
 package com.apollohg.editor
 
 import android.view.KeyEvent
+import android.view.inputmethod.BaseInputConnection
 import android.view.inputmethod.InputConnection
 import android.view.inputmethod.InputConnectionWrapper
 
@@ -16,11 +17,11 @@ import android.view.inputmethod.InputConnectionWrapper
  *
  * ## Composition (IME) Handling
  *
- * For CJK input methods (and swipe keyboards), [setComposingText] and
- * [finishComposingText] are used. During composition, we let the base [InputConnection]
- * handle composing text normally so the user sees their in-progress input with the
- * composing underline. When composition finalizes ([finishComposingText]), we capture
- * the result and route it through Rust.
+ * For CJK input methods, swipe keyboards, and some autocorrect flows, [setComposingText],
+ * [commitText], and [finishComposingText] are used together. During composition, we let
+ * the base [InputConnection] render transient composing text, but keep the original
+ * Rust-authorized replacement range so the final committed text lands at the correct
+ * document position.
  *
  * ## Key Events
  *
@@ -70,6 +71,8 @@ class EditorInputConnection(
 
     /** Tracks the current composing text for CJK/swipe input. */
     private var composingText: String? = null
+    private var composingReplacementStartUtf16: Int? = null
+    private var composingReplacementEndUtf16: Int? = null
 
     /**
      * Called when the IME commits finalized text (single character, word,
@@ -82,7 +85,26 @@ class EditorInputConnection(
         if (editorView.isApplyingRustState) {
             return super.commitText(text, newCursorPosition)
         }
-        text?.toString()?.let { editorView.handleTextCommit(it) }
+        if (editorView.editorId == 0L) {
+            return super.commitText(text, newCursorPosition)
+        }
+
+        val committedText = text?.toString()
+        val replacementRange = trackedCompositionReplacementRange()
+        if (replacementRange != null && committedText != null) {
+            clearCompositionTracking()
+            editorView.runWithTransientInputMutationGuard {
+                super.finishComposingText()
+            }
+            editorView.handleCompositionCommit(
+                committedText,
+                replacementRange.first,
+                replacementRange.second
+            )
+        } else {
+            clearCompositionTracking()
+            committedText?.let { editorView.handleTextCommit(it) }
+        }
         return true
     }
 
@@ -99,6 +121,13 @@ class EditorInputConnection(
         if (editorView.isApplyingRustState) {
             return super.deleteSurroundingText(beforeLength, afterLength)
         }
+        if (trackedCompositionReplacementRange() != null) {
+            val result = editorView.runWithTransientInputMutationGuard {
+                super.deleteSurroundingText(beforeLength, afterLength)
+            }
+            refreshComposingTextFromEditable()
+            return result
+        }
         editorView.handleDelete(beforeLength, afterLength)
         return true
     }
@@ -108,6 +137,13 @@ class EditorInputConnection(
         if (editorView.isApplyingRustState) {
             return super.deleteSurroundingTextInCodePoints(beforeLength, afterLength)
         }
+        if (trackedCompositionReplacementRange() != null) {
+            val result = editorView.runWithTransientInputMutationGuard {
+                super.deleteSurroundingTextInCodePoints(beforeLength, afterLength)
+            }
+            refreshComposingTextFromEditable()
+            return result
+        }
 
         val currentText = editorView.text?.toString().orEmpty()
         val cursor = editorView.selectionStart.coerceAtLeast(0)
@@ -132,12 +168,27 @@ class EditorInputConnection(
      *
      * We let the base InputConnection handle this normally so the user sees
      * the composing text with its underline decoration. The text is NOT sent
-     * to Rust during composition — only when [finishComposingText] is called.
+     * to Rust during composition — only when the IME commits or finishes it.
      */
     override fun setComposingText(text: CharSequence?, newCursorPosition: Int): Boolean {
         if (!editorView.isEditable) return super.setComposingText(text, newCursorPosition)
+        if (editorView.editorId == 0L) return super.setComposingText(text, newCursorPosition)
+        captureCompositionReplacementRangeIfNeeded()
         composingText = text?.toString()
-        return super.setComposingText(text, newCursorPosition)
+        return editorView.runWithTransientInputMutationGuard {
+            super.setComposingText(text, newCursorPosition)
+        }
+    }
+
+    override fun setComposingRegion(start: Int, end: Int): Boolean {
+        if (!editorView.isEditable) return super.setComposingRegion(start, end)
+        if (editorView.editorId == 0L) return super.setComposingRegion(start, end)
+        val authorizedLength = editorView.text?.length ?: 0
+        composingReplacementStartUtf16 = minOf(start, end).coerceIn(0, authorizedLength)
+        composingReplacementEndUtf16 = maxOf(start, end).coerceIn(0, authorizedLength)
+        return editorView.runWithTransientInputMutationGuard {
+            super.setComposingRegion(start, end)
+        }
     }
 
     /**
@@ -149,22 +200,60 @@ class EditorInputConnection(
      */
     override fun finishComposingText(): Boolean {
         if (!editorView.isEditable) return super.finishComposingText()
+        if (editorView.editorId == 0L) return super.finishComposingText()
         val composed = composingText
-        composingText = null
+        val replacementRange = trackedCompositionReplacementRange()
+        clearCompositionTracking()
 
         // Prevent selection sync while the base connection commits the composed
         // text, since the Rust document doesn't have it yet.
-        editorView.isApplyingRustState = true
-        val result = super.finishComposingText()
-        editorView.isApplyingRustState = false
+        val result = editorView.runWithTransientInputMutationGuard {
+            super.finishComposingText()
+        }
 
         // Now route the composed text through Rust.
-        if (!editorView.isApplyingRustState) {
-            editorView.handleCompositionFinished(composed)
+        if (replacementRange != null && !composed.isNullOrEmpty()) {
+            editorView.handleCompositionCommit(
+                composed,
+                replacementRange.first,
+                replacementRange.second
+            )
         }
         return result
     }
 
+    private fun captureCompositionReplacementRangeIfNeeded() {
+        if (trackedCompositionReplacementRange() != null) return
+        val start = editorView.selectionStart.coerceAtLeast(0)
+        val end = editorView.selectionEnd.coerceAtLeast(0)
+        val authorizedLength = editorView.text?.length ?: 0
+        composingReplacementStartUtf16 = minOf(start, end).coerceIn(0, authorizedLength)
+        composingReplacementEndUtf16 = maxOf(start, end).coerceIn(0, authorizedLength)
+    }
+
+    private fun trackedCompositionReplacementRange(): Pair<Int, Int>? {
+        val start = composingReplacementStartUtf16 ?: return null
+        val end = composingReplacementEndUtf16 ?: return null
+        return start to end
+    }
+
+    private fun clearCompositionTracking() {
+        composingText = null
+        composingReplacementStartUtf16 = null
+        composingReplacementEndUtf16 = null
+    }
+
+    private fun refreshComposingTextFromEditable() {
+        val editable = editorView.text ?: return
+        val start = BaseInputConnection.getComposingSpanStart(editable)
+        val end = BaseInputConnection.getComposingSpanEnd(editable)
+        if (start < 0 || end < 0 || start > end || end > editable.length) {
+            composingText = null
+            return
+        }
+        composingText = editable.subSequence(start, end).toString()
+    }
+
     /**
      * Called for hardware keyboard key events.
      *

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

@@ -362,6 +362,10 @@ private fun parseColor(raw: String?): Int? {
     val value = raw?.trim()?.lowercase() ?: return null
     if (value.isEmpty()) return null
 
+    when (value) {
+        "clear", "transparent" -> return Color.TRANSPARENT
+    }
+
     parseCssHexColor(value)?.let { return it }
 
     try {

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

@@ -54,6 +54,7 @@ class RichTextEditorView @JvmOverloads constructor(
     private var baseBackgroundColor: Int = Color.WHITE
     private var viewportBottomInsetPx: Int = 0
     internal var appliedCornerRadiusPx: Float = 0f
+    internal var appliedBackgroundColorForTesting: Int = Color.WHITE
 
     /** Binds or unbinds the Rust editor instance. */
     var editorId: Long = 0
@@ -251,13 +252,15 @@ class RichTextEditorView @JvmOverloads constructor(
 
     private fun updateScrollContainerAppearance() {
         val cornerRadiusPx = (theme?.borderRadius ?: 0f) * resources.displayMetrics.density
+        val backgroundColor = theme?.backgroundColor ?: baseBackgroundColor
         editorViewport.background = GradientDrawable().apply {
             cornerRadius = cornerRadiusPx
-            setColor(theme?.backgroundColor ?: baseBackgroundColor)
+            setColor(backgroundColor)
         }
         editorViewport.clipToOutline = cornerRadiusPx > 0f
         editorScrollView.setBackgroundColor(Color.TRANSPARENT)
         appliedCornerRadiusPx = cornerRadiusPx
+        appliedBackgroundColorForTesting = backgroundColor
     }
 
     private fun updateScrollContainerInsets() {

package/ios/EditorCore.xcframework/Info.plist

@@ -8,32 +8,32 @@
 			<key>BinaryPath</key>
 			<string>libeditor_core.a</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64</string>
+			<string>ios-arm64_x86_64-simulator</string>
 			<key>LibraryPath</key>
 			<string>libeditor_core.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
+				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
 		</dict>
 		<dict>
 			<key>BinaryPath</key>
 			<string>libeditor_core.a</string>
 			<key>LibraryIdentifier</key>
-			<string>ios-arm64_x86_64-simulator</string>
+			<string>ios-arm64</string>
 			<key>LibraryPath</key>
 			<string>libeditor_core.a</string>
 			<key>SupportedArchitectures</key>
 			<array>
 				<string>arm64</string>
-				<string>x86_64</string>
 			</array>
 			<key>SupportedPlatform</key>
 			<string>ios</string>
-			<key>SupportedPlatformVariant</key>
-			<string>simulator</string>
 		</dict>
 	</array>
 	<key>CFBundlePackageType</key>

package/ios/NativeEditorExpoView.swift

@@ -1576,6 +1576,46 @@ final class EditorAccessoryToolbarView: UIInputView {
     }
 }
 
+/// Keeps iOS keyboard integrations on the inputAccessoryView path when the
+/// visible toolbar is rendered outside the native keyboard accessory.
+final class EditorAccessoryPlaceholderView: UIView {
+    override init(frame: CGRect) {
+        super.init(
+            frame: CGRect(
+                x: frame.origin.x,
+                y: frame.origin.y,
+                width: frame.width,
+                height: 0
+            )
+        )
+        commonInit()
+    }
+
+    required init?(coder: NSCoder) {
+        return nil
+    }
+
+    override var intrinsicContentSize: CGSize {
+        CGSize(width: UIView.noIntrinsicMetric, height: 0)
+    }
+
+    override func sizeThatFits(_ size: CGSize) -> CGSize {
+        CGSize(width: size.width, height: 0)
+    }
+
+    override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
+        false
+    }
+
+    private func commonInit() {
+        frame.size.height = 0
+        backgroundColor = .clear
+        isOpaque = false
+        isUserInteractionEnabled = false
+        autoresizingMask = [.flexibleWidth]
+    }
+}
+
 class NativeEditorExpoView: ExpoView, EditorTextViewDelegate, UIGestureRecognizerDelegate {
 
     // MARK: - Subviews
@@ -1585,6 +1625,7 @@ class NativeEditorExpoView: ExpoView, EditorTextViewDelegate, UIGestureRecognize
         frame: .zero,
         inputViewStyle: .keyboard
     )
+    private let accessoryPlaceholder = EditorAccessoryPlaceholderView(frame: .zero)
     private var toolbarFrameInWindow: CGRect?
     private var didApplyAutoFocus = false
     private var toolbarState = NativeToolbarState.empty
@@ -2269,14 +2310,33 @@ class NativeEditorExpoView: ExpoView, EditorTextViewDelegate, UIGestureRecognize
     func triggerMentionSuggestionTapForTesting(at index: Int) {
         accessoryToolbar.triggerMentionSuggestionTapForTesting(at: index)
     }
+
+    func inputAccessoryViewForTesting() -> UIView? {
+        richTextView.textView.inputAccessoryView
+    }
+
+    func isUsingAccessoryToolbarForTesting() -> Bool {
+        richTextView.textView.inputAccessoryView === accessoryToolbar
+    }
+
+    func isUsingAccessoryPlaceholderForTesting() -> Bool {
+        richTextView.textView.inputAccessoryView === accessoryPlaceholder
+    }
+
     private func updateAccessoryToolbarVisibility() {
         refreshSystemAssistantToolbarIfNeeded()
-        let nextAccessoryView: UIView? = showsToolbar &&
+        let nextAccessoryView: UIView?
+        if showsToolbar &&
             toolbarPlacement == "keyboard" &&
             richTextView.textView.isEditable &&
             !shouldUseSystemAssistantToolbar
-            ? accessoryToolbar
-            : nil
+        {
+            nextAccessoryView = accessoryToolbar
+        } else if richTextView.textView.isEditable && !shouldUseSystemAssistantToolbar {
+            nextAccessoryView = accessoryPlaceholder
+        } else {
+            nextAccessoryView = nil
+        }
         if richTextView.textView.inputAccessoryView !== nextAccessoryView {
             richTextView.textView.inputAccessoryView = nextAccessoryView
             if richTextView.textView.isFirstResponder {

package/ios/RichTextEditorView.swift

@@ -704,7 +704,8 @@ private final class ImageResizeOverlayView: UIView {
 /// For CJK input methods, `setMarkedText` / `unmarkText` are used. During
 /// composition (marked text), we let UITextView handle it normally so the
 /// user sees their composing text. When composition finalizes (`unmarkText`),
-/// we capture the result and route it through Rust.
+/// we commit the final text through Rust at the original Rust-authorized
+/// replacement range.
 ///
 /// ## Thread Safety
 ///
@@ -970,9 +971,12 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     private var pendingDeferredImageSelectionRange: NSRange?
     private var pendingDeferredImageSelectionGeneration: UInt64 = 0
 
-    /// Stores the text that was composed during a marked text session,
-    /// captured when `unmarkText` is called.
-    private var composedText: String?
+    /// Stores the Rust-authorized scalar range replaced by the active marked
+    /// text session. UIKit mutates visible TextKit state during composition,
+    /// so final commits must not infer their range from the transient cursor.
+    private var markedTextReplacementScalarRange: (from: UInt32, to: UInt32)?
+    private var markedTextReplacementUtf16Range: NSRange?
+    private var markedTextCompositionText: String?
 
     private let editorLayoutManager: EditorLayoutManager
 
@@ -1050,7 +1054,7 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
         // Register as the text storage delegate so we can detect unauthorized
         // mutations (reconciliation fallback).
         textStorage.delegate = self
-        delegate = self
+        ensureInternalTextViewDelegate()
         addGestureRecognizer(imageSelectionTapRecognizer)
         installImageSelectionTapDependencies()
 
@@ -1161,6 +1165,10 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     override func becomeFirstResponder() -> Bool {
         let didBecomeFirstResponder = super.becomeFirstResponder()
         if didBecomeFirstResponder {
+            ensureInternalTextViewDelegate()
+            DispatchQueue.main.async { [weak self] in
+                self?.ensureInternalTextViewDelegate()
+            }
             _ = normalizeSelectionForEmptyBlockAutocapitalizationIfNeeded()
             refreshTypingAttributesForSelection()
         }
@@ -1340,6 +1348,10 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
         lastApplyUpdateTraceForTesting
     }
 
+    func isUsingInternalTextViewDelegateForTesting() -> Bool {
+        (delegate as AnyObject?) === (self as AnyObject)
+    }
+
     func blockquoteStripeRectsForTesting() -> [CGRect] {
         editorLayoutManager.blockquoteStripeRectsForTesting(in: textStorage)
     }
@@ -1533,6 +1545,7 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     ///   - id: The editor ID from `editor_create()`.
     ///   - initialHTML: Optional HTML to set as initial content.
     func bindEditor(id: UInt64, initialHTML: String? = nil) {
+        ensureInternalTextViewDelegate()
         editorId = id
 
         if let html = initialHTML, !html.isEmpty {
@@ -1561,6 +1574,7 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     /// Instead of calling `super.insertText()` (which would modify the
     /// underlying text storage directly), we route through Rust.
     override func insertText(_ text: String) {
+        ensureInternalTextViewDelegate()
         guard !isApplyingRustState else {
             super.insertText(text)
             return
@@ -1570,6 +1584,13 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
             return
         }
 
+        if markedTextReplacementScalarRange != nil || markedTextRange != nil {
+            let replacementRange = trackedMarkedTextReplacementRange()
+            finishTransientMarkedTextMutation()
+            commitMarkedText(text, replacementRange: replacementRange)
+            return
+        }
+
         // Handle Enter/Return as a block split operation.
         if text == "\n" {
             performInterceptedInput {
@@ -1644,6 +1665,7 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     /// If there's a range selection, delete the range. If it's a cursor,
     /// delete the character (grapheme cluster) before the cursor.
     override func deleteBackward() {
+        ensureInternalTextViewDelegate()
         guard !isApplyingRustState else {
             super.deleteBackward()
             return
@@ -1653,6 +1675,15 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
             return
         }
 
+        if markedTextReplacementScalarRange != nil || markedTextRange != nil {
+            performTransientTextMutation {
+                super.deleteBackward()
+            }
+            refreshMarkedTextCompositionText()
+            isComposing = markedTextRange != nil || markedTextReplacementScalarRange != nil
+            return
+        }
+
         guard let selectedRange = selectedTextRange else { return }
         Self.inputLog.debug(
             "[deleteBackward] selection=\(self.selectionSummary(), privacy: .public) textState=\(self.textSnapshotSummary(), privacy: .public)"
@@ -1837,6 +1868,7 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     ///
     /// We route the replacement through Rust to keep the document model in sync.
     override func replace(_ range: UITextRange, withText text: String) {
+        ensureInternalTextViewDelegate()
         guard !isApplyingRustState else {
             super.replace(range, withText: text)
             return
@@ -1846,6 +1878,13 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
             return
         }
 
+        if markedTextReplacementScalarRange != nil || markedTextRange != nil {
+            let replacementRange = trackedMarkedTextReplacementRange()
+            finishTransientMarkedTextMutation()
+            commitMarkedText(text, replacementRange: replacementRange)
+            return
+        }
+
         let scalarRange = PositionBridge.textRangeToScalarRange(range, in: self)
         Self.inputLog.debug(
             "[replace] text=\(self.preview(text), privacy: .public) scalarRange=\(scalarRange.from)-\(scalarRange.to) selection=\(self.selectionSummary(), privacy: .public) textState=\(self.textSnapshotSummary(), privacy: .public)"
@@ -1871,45 +1910,179 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     /// UITextView display the composing text normally (with its underline
     /// decoration). The text is NOT sent to Rust during composition.
     override func setMarkedText(_ markedText: String?, selectedRange: NSRange) {
-        isComposing = true
+        ensureInternalTextViewDelegate()
+        if markedText != nil {
+            captureMarkedTextReplacementRangeIfNeeded()
+        }
+        isComposing = markedText != nil || markedTextReplacementScalarRange != nil
         Self.inputLog.debug(
             "[setMarkedText] marked=\(self.preview(markedText ?? ""), privacy: .public) nsRange=\(selectedRange.location),\(selectedRange.length) selection=\(self.selectionSummary(), privacy: .public)"
         )
-        super.setMarkedText(markedText, selectedRange: selectedRange)
+        performTransientTextMutation {
+            super.setMarkedText(markedText, selectedRange: selectedRange)
+        }
+        if markedText == nil {
+            clearMarkedTextTracking()
+            restoreAuthorizedTextAfterCancelledCompositionIfNeeded()
+        } else {
+            refreshMarkedTextCompositionText(fallback: markedText)
+        }
     }
 
     /// Called when composition is finalized (user selects a candidate or
     /// presses space/enter to commit).
     ///
-    /// At this point, the composed text is final. We capture it and send
-    /// it to Rust as a single insertion. `unmarkText` in UITextView will
-    /// replace the marked text with the final text in the text storage,
-    /// but we intercept at a higher level.
+    /// At this point, the composed text is final. We capture it and commit it
+    /// to Rust at the original replacement range captured before UIKit mutated
+    /// the transient text storage.
     override func unmarkText() {
-        // Capture the finalized composed text before UIKit clears it.
-        composedText = markedTextRange.flatMap { text(in: $0) }
+        ensureInternalTextViewDelegate()
+        let composedText = currentMarkedTextForCommit()
+        let replacementRange = trackedMarkedTextReplacementRange()
 
-        // Prevent selection sync while UIKit commits the marked text, since
-        // the Rust document doesn't have the composed text yet.
-        isApplyingRustState = true
-        super.unmarkText()
-        isApplyingRustState = false
-        isComposing = false
+        finishTransientMarkedTextMutation()
 
-        // Now route the composed text through Rust. The cursor is at the end
-        // of the composed text, so the insert position is cursor - length.
-        if let composed = composedText, !composed.isEmpty, editorId != 0 {
-            let cursorPos = PositionBridge.cursorScalarOffset(in: self)
-            let composedScalars = UInt32(composed.unicodeScalars.count)
-            let insertPos = cursorPos >= composedScalars ? cursorPos - composedScalars : 0
+        if let composed = composedText, !composed.isEmpty {
             Self.inputLog.debug(
-                "[unmarkText] composed=\(self.preview(composed), privacy: .public) cursorPos=\(cursorPos) insertPos=\(insertPos) selection=\(self.selectionSummary(), privacy: .public)"
+                "[unmarkText] composed=\(self.preview(composed), privacy: .public) replacement=\(self.previewMarkedTextReplacementRange(replacementRange), privacy: .public) selection=\(self.selectionSummary(), privacy: .public)"
             )
+            commitMarkedText(composed, replacementRange: replacementRange)
+        } else {
+            restoreAuthorizedTextAfterCancelledCompositionIfNeeded()
+        }
+    }
+
+    private func captureMarkedTextReplacementRangeIfNeeded() {
+        guard markedTextReplacementScalarRange == nil else { return }
+
+        guard let selectedRange = selectedTextRange else {
+            let scalarPos = PositionBridge.cursorScalarOffset(in: self)
+            markedTextReplacementScalarRange = (from: scalarPos, to: scalarPos)
+            markedTextReplacementUtf16Range = NSRange(
+                location: Int(scalarPos),
+                length: 0
+            )
+            return
+        }
+
+        let scalarRange = PositionBridge.textRangeToScalarRange(selectedRange, in: self)
+        let startUtf16 = offset(from: beginningOfDocument, to: selectedRange.start)
+        let endUtf16 = offset(from: beginningOfDocument, to: selectedRange.end)
+
+        markedTextReplacementScalarRange = (from: scalarRange.from, to: scalarRange.to)
+        markedTextReplacementUtf16Range = NSRange(
+            location: min(startUtf16, endUtf16),
+            length: abs(endUtf16 - startUtf16)
+        )
+    }
+
+    private func trackedMarkedTextReplacementRange() -> (from: UInt32, to: UInt32)? {
+        if let markedTextReplacementScalarRange {
+            return markedTextReplacementScalarRange
+        }
+        guard let selectedRange = selectedTextRange else { return nil }
+        let scalarRange = PositionBridge.textRangeToScalarRange(selectedRange, in: self)
+        return (from: scalarRange.from, to: scalarRange.to)
+    }
+
+    private func clearMarkedTextTracking() {
+        markedTextReplacementScalarRange = nil
+        markedTextReplacementUtf16Range = nil
+        markedTextCompositionText = nil
+        isComposing = false
+    }
+
+    private func finishTransientMarkedTextMutation() {
+        performTransientTextMutation {
+            super.unmarkText()
+        }
+        clearMarkedTextTracking()
+    }
+
+    private func performTransientTextMutation(_ action: () -> Void) {
+        let wasApplyingRustState = isApplyingRustState
+        isApplyingRustState = true
+        action()
+        isApplyingRustState = wasApplyingRustState
+    }
+
+    private func currentMarkedTextForCommit() -> String? {
+        markedTextRange.flatMap { text(in: $0) }
+            ?? markedTextCompositionText
+            ?? transientMarkedTextFromAuthorizedDiff()
+    }
+
+    private func refreshMarkedTextCompositionText(fallback: String? = nil) {
+        markedTextCompositionText = markedTextRange.flatMap { text(in: $0) }
+            ?? transientMarkedTextFromAuthorizedDiff()
+            ?? fallback
+    }
+
+    private func transientMarkedTextFromAuthorizedDiff() -> String? {
+        guard let replacementRange = markedTextReplacementUtf16Range else { return nil }
+
+        let currentText = textStorage.string as NSString
+        let authorizedText = lastAuthorizedText as NSString
+        let replacementEnd = replacementRange.location + replacementRange.length
+        guard replacementRange.location >= 0,
+              replacementEnd <= authorizedText.length
+        else {
+            return nil
+        }
+
+        let insertedLength = currentText.length - (authorizedText.length - replacementRange.length)
+        guard insertedLength >= 0,
+              replacementRange.location + insertedLength <= currentText.length
+        else {
+            return nil
+        }
+
+        return currentText.substring(
+            with: NSRange(location: replacementRange.location, length: insertedLength)
+        )
+    }
+
+    private func commitMarkedText(
+        _ text: String,
+        replacementRange: (from: UInt32, to: UInt32)?
+    ) {
+        guard editorId != 0 else { return }
+        guard let replacementRange else {
             performInterceptedInput {
-                insertTextInRust(composed, at: insertPos)
+                insertTextInRust(text, at: PositionBridge.cursorScalarOffset(in: self))
+            }
+            return
+        }
+
+        performInterceptedInput {
+            if replacementRange.from == replacementRange.to {
+                insertTextInRust(text, at: replacementRange.from)
+            } else {
+                replaceTextRangeInRust(
+                    from: replacementRange.from,
+                    to: replacementRange.to,
+                    with: text
+                )
             }
         }
-        composedText = nil
+    }
+
+    private func restoreAuthorizedTextAfterCancelledCompositionIfNeeded() {
+        guard editorId != 0 else { return }
+        guard textStorage.string != lastAuthorizedText else { return }
+
+        let stateJSON = editorGetCurrentState(id: editorId)
+        applyUpdateJSON(stateJSON)
+    }
+
+    private func previewMarkedTextReplacementRange(
+        _ range: (from: UInt32, to: UInt32)?
+    ) -> String {
+        guard let range else { return "none" }
+        let utf16 = markedTextReplacementUtf16Range
+            .map { "\($0.location)..<\($0.location + $0.length)" }
+            ?? "none"
+        return "scalar=\(range.from)..<\(range.to) utf16=\(utf16)"
     }
 
     // MARK: - Paste Handling
@@ -1919,6 +2092,7 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     /// Attempts to extract HTML from the pasteboard first (for rich text paste),
     /// falling back to plain text.
     override func paste(_ sender: Any?) {
+        ensureInternalTextViewDelegate()
         guard editorId != 0 else {
             super.paste(sender)
             return
@@ -1977,7 +2151,8 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     /// internally during tap handling and word-boundary resolution.
     func textViewDidChangeSelection(_ textView: UITextView) {
         guard textView === self else { return }
-        guard !isApplyingRustState else { return }
+        ensureInternalTextViewDelegate()
+        guard !isApplyingRustState, !isComposing else { return }
         if normalizeSelectionForEmptyBlockAutocapitalizationIfNeeded() {
             return
         }
@@ -2029,6 +2204,14 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
         interceptedInputDepth > 0
     }
 
+    private func ensureInternalTextViewDelegate() {
+        // Some keyboard integrations replace UITextView's private delegate ivar
+        // directly. The editor must own delegate callbacks so external observers
+        // cannot inspect transient TextKit state during Rust-driven edits.
+        guard (delegate as AnyObject?) !== (self as AnyObject) else { return }
+        delegate = self
+    }
+
     private func performInterceptedInput(_ action: () -> Void) {
         interceptedInputDepth += 1
         Self.inputLog.debug(
@@ -2150,7 +2333,7 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     }
 
     private func syncSelectionToRustAndNotifyDelegate() {
-        guard !isApplyingRustState, editorId != 0 else { return }
+        guard !isApplyingRustState, !isComposing, editorId != 0 else { return }
         guard let range = selectedTextRange else { return }
 
         let anchor = PositionBridge.textViewToScalar(range.start, in: self)
@@ -2744,6 +2927,19 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
         applyUpdateJSON(updateJSON)
     }
 
+    private func replaceTextRangeInRust(from: UInt32, to: UInt32, with text: String) {
+        Self.inputLog.debug(
+            "[rust.replaceTextScalar] text=\(self.preview(text), privacy: .public) scalar=\(from)-\(to) selection=\(self.selectionSummary(), privacy: .public)"
+        )
+        let updateJSON = editorReplaceTextScalar(
+            id: editorId,
+            scalarFrom: from,
+            scalarTo: to,
+            text: text
+        )
+        applyUpdateJSON(updateJSON)
+    }
+
     private func insertNodeInRust(_ nodeType: String) {
         guard let selection = currentScalarSelection() else { return }
         Self.inputLog.debug(
@@ -3236,12 +3432,11 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
         var stringMutationNanos: UInt64 = 0
         var attributeMutationNanos: UInt64 = 0
         let previousTextStorageDelegate = textStorage.delegate
-        let previousTextViewDelegate = delegate
         textStorage.delegate = nil
         delegate = nil
         defer {
             textStorage.delegate = previousTextStorageDelegate
-            delegate = previousTextViewDelegate
+            ensureInternalTextViewDelegate()
         }
         if let replaceRange {
             if shouldUseSmallPatchTextMutation {
@@ -3810,6 +4005,7 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     ///
     /// - Parameter updateJSON: The JSON string from editor_insert_text, etc.
     func applyUpdateJSON(_ updateJSON: String, notifyDelegate: Bool = true) {
+        ensureInternalTextViewDelegate()
         let totalStartedAt = DispatchTime.now().uptimeNanoseconds
         let parseStartedAt = totalStartedAt
         guard let data = updateJSON.data(using: .utf8),
@@ -3996,6 +4192,7 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
     /// Used for initial content loading (set_html / set_json return render
     /// elements directly, not wrapped in an EditorUpdate).
     func applyRenderJSON(_ renderJSON: String) {
+        ensureInternalTextViewDelegate()
         Self.updateLog.debug(
             "[applyRenderJSON.begin] before=\(self.textSnapshotSummary(), privacy: .public)"
         )
@@ -4031,7 +4228,11 @@ final class EditorTextView: UITextView, UITextViewDelegate, UIGestureRecognizerD
 
         let totalStartedAt = DispatchTime.now().uptimeNanoseconds
         isApplyingRustState = true
-        defer { isApplyingRustState = false }
+        delegate = nil
+        defer {
+            ensureInternalTextViewDelegate()
+            isApplyingRustState = false
+        }
 
         switch type {
         case "text":
@@ -4176,7 +4377,7 @@ extension EditorTextView: NSTextStorageDelegate {
         guard editedMask.contains(.editedCharacters) else { return }
 
         // Skip if this change came from our own Rust apply path.
-        guard !isApplyingRustState, !isInterceptingInput else { return }
+        guard !isApplyingRustState, !isInterceptingInput, !isComposing else { return }
 
         // Skip if no editor is bound yet (nothing to reconcile against).
         guard editorId != 0 else { return }
@@ -4218,7 +4419,7 @@ extension EditorTextView: NSTextStorageDelegate {
             guard let self else { return }
             self.reconciliationWorkScheduled = false
 
-            guard !self.isApplyingRustState, !self.isInterceptingInput else { return }
+            guard !self.isApplyingRustState, !self.isInterceptingInput, !self.isComposing else { return }
             guard self.editorId != 0 else { return }
             guard self.textStorage.string != self.lastAuthorizedText else { return }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@apollohg/react-native-prose-editor",
-    "version": "0.5.8",
+    "version": "0.5.10",
     "description": "Native rich text editor with Rust core for React Native",
     "license": "Apache-2.0",
     "homepage": "https://github.com/apollohg/react-native-prose-editor",