@apollohg/react-native-prose-editor 0.3.0 → 0.4.1

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

@@ -5,10 +5,12 @@ import android.content.Context
 import android.graphics.Typeface
 import android.graphics.Rect
 import android.graphics.RectF
+import android.text.Annotation
 import android.text.Editable
 import android.text.Layout
 import android.text.Spanned
 import android.text.StaticLayout
+import android.text.TextPaint
 import android.text.TextWatcher
 import android.util.AttributeSet
 import android.util.Log
@@ -51,11 +53,43 @@ class EditorEditText @JvmOverloads constructor(
     attrs: AttributeSet? = null,
     defStyleAttr: Int = android.R.attr.editTextStyle
 ) : AppCompatEditText(context, attrs, defStyleAttr) {
+    data class ApplyUpdateTrace(
+        val attemptedPatch: Boolean,
+        val usedPatch: Boolean,
+        val skippedRender: Boolean,
+        val parseNanos: Long,
+        val resolveRenderBlocksNanos: Long,
+        val patchEligibilityNanos: Long,
+        val buildRenderNanos: Long,
+        val applyRenderNanos: Long,
+        val selectionNanos: Long,
+        val postApplyNanos: Long,
+        val totalNanos: Long
+    )
+
     data class SelectedImageGeometry(
         val docPos: Int,
         val rect: RectF
     )
 
+    private data class ParsedRenderPatch(
+        val startIndex: Int,
+        val deleteCount: Int,
+        val renderBlocks: org.json.JSONArray
+    )
+
+    private data class RenderReplaceRange(
+        val start: Int,
+        val endExclusive: Int
+    )
+
+    private data class PatchApplyTrace(
+        val applied: Boolean,
+        val eligibilityNanos: Long,
+        val buildRenderNanos: Long,
+        val applyRenderNanos: Long
+    )
+
     private data class ImageSelectionRange(
         val start: Int,
         val end: Int
@@ -109,7 +143,9 @@ class EditorEditText @JvmOverloads constructor(
 
     var placeholderText: String = ""
         set(value) {
+            if (field == value) return
             field = value
+            requestLayout()
             invalidate()
         }
 
@@ -136,6 +172,17 @@ class EditorEditText @JvmOverloads constructor(
     private var lastHandledHardwareKeyCode: Int? = null
     private var lastHandledHardwareKeyDownTime: Long? = null
     private var explicitSelectedImageRange: ImageSelectionRange? = null
+    private var lastRenderAppliedPatchForTesting: Boolean = false
+    internal var captureApplyUpdateTraceForTesting: Boolean = false
+    private var lastApplyUpdateTraceForTesting: ApplyUpdateTrace? = null
+    private var currentRenderBlocksJson: org.json.JSONArray? = null
+    private var renderAppearanceRevision: Long = 1L
+    private var lastAppliedRenderAppearanceRevision: Long = 0L
+    internal var onDeleteRangeInRustForTesting: ((Int, Int) -> Unit)? = null
+    internal var onDeleteBackwardAtSelectionScalarInRustForTesting: ((Int, Int) -> Unit)? = null
+
+    fun lastRenderAppliedPatch(): Boolean = lastRenderAppliedPatchForTesting
+    fun lastApplyUpdateTrace(): ApplyUpdateTrace? = lastApplyUpdateTraceForTesting
 
     init {
         // Configure for rich text editing.
@@ -186,25 +233,33 @@ class EditorEditText @JvmOverloads constructor(
     override fun onDraw(canvas: android.graphics.Canvas) {
         super.onDraw(canvas)
 
-        if (!shouldDisplayPlaceholder()) return
-
-        val availableWidth = width - compoundPaddingLeft - compoundPaddingRight
-        if (availableWidth <= 0) return
+        val placeholderLayout =
+            buildPlaceholderLayout(width - compoundPaddingLeft - compoundPaddingRight) ?: return
 
         val previousColor = paint.color
         val saveCount = canvas.save()
-        paint.color = currentHintTextColor
         canvas.translate(compoundPaddingLeft.toFloat(), extendedPaddingTop.toFloat())
-        StaticLayout.Builder
-            .obtain(placeholderText, 0, placeholderText.length, paint, availableWidth)
-            .setAlignment(Layout.Alignment.ALIGN_NORMAL)
-            .setIncludePad(includeFontPadding)
-            .build()
-            .draw(canvas)
+        placeholderLayout.draw(canvas)
         canvas.restoreToCount(saveCount)
         paint.color = previousColor
     }
 
+    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
+        super.onMeasure(widthMeasureSpec, heightMeasureSpec)
+
+        val placeholderHeight = resolvePlaceholderHeightForMeasuredWidth(measuredWidth) ?: return
+        val desiredHeight = maxOf(measuredHeight, placeholderHeight)
+        val resolvedHeight = when (MeasureSpec.getMode(heightMeasureSpec)) {
+            MeasureSpec.EXACTLY -> measuredHeight
+            MeasureSpec.AT_MOST -> desiredHeight.coerceAtMost(MeasureSpec.getSize(heightMeasureSpec))
+            else -> desiredHeight
+        }
+
+        if (resolvedHeight != measuredHeight) {
+            setMeasuredDimension(measuredWidth, resolvedHeight)
+        }
+    }
+
     override fun onTouchEvent(event: MotionEvent): Boolean {
         if (event.actionMasked == MotionEvent.ACTION_DOWN && imageSpanHitAt(event.x, event.y) == null) {
             clearExplicitSelectedImageRange()
@@ -250,6 +305,59 @@ class EditorEditText @JvmOverloads constructor(
 
     fun shouldDisplayPlaceholderForTesting(): Boolean = shouldDisplayPlaceholder()
 
+    private fun buildPlaceholderLayout(availableWidth: Int): StaticLayout? {
+        if (!shouldDisplayPlaceholder()) return null
+        if (availableWidth <= 0) return null
+
+        val placeholderPaint = resolvedPlaceholderPaint()
+        return StaticLayout.Builder
+            .obtain(
+                placeholderText,
+                0,
+                placeholderText.length,
+                placeholderPaint,
+                availableWidth
+            )
+            .setAlignment(Layout.Alignment.ALIGN_NORMAL)
+            .setIncludePad(includeFontPadding)
+            .build()
+    }
+
+    private fun resolvedPlaceholderPaint(): TextPaint {
+        val textStyle = theme?.effectiveTextStyle("paragraph")
+        val resolvedTextSize = textStyle?.fontSize?.times(resources.displayMetrics.density) ?: baseFontSize
+        val resolvedTypeface = resolvePlaceholderTypeface(textStyle)
+
+        return TextPaint(paint).apply {
+            color = currentHintTextColor
+            textSize = resolvedTextSize
+            typeface = resolvedTypeface
+        }
+    }
+
+    private fun resolvePlaceholderTypeface(textStyle: EditorTextStyle?): Typeface {
+        val baseTypeface = typeface ?: Typeface.DEFAULT
+        val requestedStyle = textStyle?.typefaceStyle() ?: Typeface.NORMAL
+        val family = textStyle?.fontFamily?.takeIf { it.isNotBlank() }
+
+        return when {
+            family != null -> Typeface.create(family, requestedStyle)
+            requestedStyle != Typeface.NORMAL -> Typeface.create(baseTypeface, requestedStyle)
+            else -> baseTypeface
+        }
+    }
+
+    private fun resolvePlaceholderHeightForMeasuredWidth(widthPx: Int): Int? {
+        val availableWidth = (widthPx - compoundPaddingLeft - compoundPaddingRight).coerceAtLeast(0)
+        return resolvePlaceholderHeightForAvailableWidth(availableWidth)
+    }
+
+    private fun resolvePlaceholderHeightForAvailableWidth(availableWidth: Int): Int? {
+        val placeholderLayout = buildPlaceholderLayout(availableWidth) ?: return null
+        val placeholderHeight = placeholderLayout.height.takeIf { it > 0 } ?: lineHeight
+        return placeholderHeight + compoundPaddingTop + compoundPaddingBottom
+    }
+
     // ── Editor Binding ──────────────────────────────────────────────────
 
     /**
@@ -262,8 +370,9 @@ class EditorEditText @JvmOverloads constructor(
         editorId = id
 
         if (!initialHTML.isNullOrEmpty()) {
-            val renderJSON = editorSetHtml(editorId.toULong(), initialHTML)
-            applyRenderJSON(renderJSON)
+            editorSetHtml(editorId.toULong(), initialHTML)
+            val stateJSON = editorGetCurrentState(editorId.toULong())
+            applyUpdateJSON(stateJSON, notifyListener = false)
         } else {
             // Pull current state from Rust (content may already be loaded via bridge).
             val stateJSON = editorGetCurrentState(editorId.toULong())
@@ -279,6 +388,9 @@ class EditorEditText @JvmOverloads constructor(
     }
 
     fun setBaseStyle(fontSizePx: Float, textColor: Int, backgroundColor: Int) {
+        if (baseFontSize != fontSizePx || baseTextColor != textColor) {
+            renderAppearanceRevision += 1L
+        }
         baseFontSize = fontSizePx
         baseTextColor = textColor
         baseBackgroundColor = backgroundColor
@@ -289,6 +401,7 @@ class EditorEditText @JvmOverloads constructor(
 
     fun applyTheme(theme: EditorTheme?) {
         this.theme = theme
+        renderAppearanceRevision += 1L
         setBackgroundColor(theme?.backgroundColor ?: baseBackgroundColor)
         applyContentInsets(theme?.contentInsets)
         if (editorId != 0L) {
@@ -358,12 +471,16 @@ class EditorEditText @JvmOverloads constructor(
     }
 
     fun resolveAutoGrowHeight(): Int {
+        val availableWidth = (measuredWidth - compoundPaddingLeft - compoundPaddingRight).coerceAtLeast(0)
+        val placeholderHeight = resolvePlaceholderHeightForAvailableWidth(availableWidth)
         val laidOutTextHeight = if (isLaidOut) layout?.height else null
         if (laidOutTextHeight != null && laidOutTextHeight > 0) {
-            return laidOutTextHeight + compoundPaddingTop + compoundPaddingBottom
+            return maxOf(
+                laidOutTextHeight + compoundPaddingTop + compoundPaddingBottom,
+                placeholderHeight ?: 0
+            )
         }
 
-        val availableWidth = (measuredWidth - compoundPaddingLeft - compoundPaddingRight).coerceAtLeast(0)
         val currentText = text
         if (availableWidth > 0 && currentText != null) {
             val staticLayout = StaticLayout.Builder
@@ -372,11 +489,17 @@ class EditorEditText @JvmOverloads constructor(
                 .setIncludePad(includeFontPadding)
                 .build()
             val textHeight = staticLayout.height.takeIf { it > 0 } ?: lineHeight
-            return textHeight + compoundPaddingTop + compoundPaddingBottom
+            return maxOf(
+                textHeight + compoundPaddingTop + compoundPaddingBottom,
+                placeholderHeight ?: 0
+            )
         }
 
         val minimumHeight = suggestedMinimumHeight.coerceAtLeast(minHeight)
-        return (lineHeight + compoundPaddingTop + compoundPaddingBottom).coerceAtLeast(minimumHeight)
+        return maxOf(
+            placeholderHeight ?: 0,
+            (lineHeight + compoundPaddingTop + compoundPaddingBottom).coerceAtLeast(minimumHeight)
+        )
     }
 
     private fun preserveScrollPosition(previousScrollX: Int, previousScrollY: Int) {
@@ -485,6 +608,15 @@ class EditorEditText @JvmOverloads constructor(
 
         val currentText = text?.toString() ?: ""
         val cursor = selectionStart
+        if (beforeLength > 0 &&
+            afterLength == 0 &&
+            cursor > 0 &&
+            currentText.getOrNull(cursor - 1) == EMPTY_BLOCK_PLACEHOLDER
+        ) {
+            val scalarCursor = PositionBridge.utf16ToScalar(cursor - 1, currentText)
+            deleteBackwardAtSelectionScalarInRust(scalarCursor, scalarCursor)
+            return
+        }
         val delStart = maxOf(0, cursor - beforeLength)
         val delEnd = minOf(currentText.length, cursor + afterLength)
 
@@ -493,6 +625,8 @@ class EditorEditText @JvmOverloads constructor(
 
         if (scalarStart < scalarEnd) {
             deleteRangeInRust(scalarStart, scalarEnd)
+        } else if (beforeLength > 0 && afterLength == 0) {
+            deleteBackwardAtSelectionScalarInRust(scalarEnd, scalarEnd)
         }
     }
 
@@ -531,6 +665,11 @@ class EditorEditText @JvmOverloads constructor(
             val scalarEnd = PositionBridge.utf16ToScalar(end, currentText)
             deleteRangeInRust(scalarStart, scalarEnd)
         } else if (start > 0) {
+            if (currentText.getOrNull(start - 1) == EMPTY_BLOCK_PLACEHOLDER) {
+                val scalarCursor = PositionBridge.utf16ToScalar(start - 1, currentText)
+                deleteBackwardAtSelectionScalarInRust(scalarCursor, scalarCursor)
+                return
+            }
             // Cursor: delete one grapheme cluster backward.
             // Find the previous grapheme boundary by snapping (start - 1).
             val breakIter = java.text.BreakIterator.getCharacterInstance()
@@ -540,7 +679,13 @@ class EditorEditText @JvmOverloads constructor(
 
             val scalarStart = PositionBridge.utf16ToScalar(prevUtf16, currentText)
             val scalarEnd = PositionBridge.utf16ToScalar(start, currentText)
-            deleteRangeInRust(scalarStart, scalarEnd)
+            if (scalarStart < scalarEnd) {
+                deleteRangeInRust(scalarStart, scalarEnd)
+            } else {
+                deleteBackwardAtSelectionScalarInRust(scalarEnd, scalarEnd)
+            }
+        } else {
+            deleteBackwardAtSelectionScalarInRust(0, 0)
         }
     }
 
@@ -765,6 +910,19 @@ class EditorEditText @JvmOverloads constructor(
         applyUpdateJSON(updateJSON)
     }
 
+    fun performToolbarToggleHeading(level: Int) {
+        if (!isEditable || isApplyingRustState || editorId == 0L) return
+        if (level !in 1..6) return
+        val selection = currentScalarSelection() ?: return
+        val updateJSON = editorToggleHeadingAtSelectionScalar(
+            editorId.toULong(),
+            selection.first.toUInt(),
+            selection.second.toUInt(),
+            level.toUByte()
+        )
+        applyUpdateJSON(updateJSON)
+    }
+
     fun performToolbarIndentListItem() {
         if (!isEditable || isApplyingRustState || editorId == 0L) return
         val selection = currentScalarSelection() ?: return
@@ -876,6 +1034,7 @@ class EditorEditText @JvmOverloads constructor(
      */
     override fun onSelectionChanged(selStart: Int, selEnd: Int) {
         super.onSelectionChanged(selStart, selEnd)
+        if (isApplyingRustState) return
         val spannable = text as? Spanned
         if (spannable != null && isExactImageSpanRange(spannable, selStart, selEnd)) {
             explicitSelectedImageRange = ImageSelectionRange(selStart, selEnd)
@@ -883,7 +1042,7 @@ class EditorEditText @JvmOverloads constructor(
         ensureSelectionVisible()
         onSelectionOrContentMayChange?.invoke()
 
-        if (isApplyingRustState || editorId == 0L) return
+        if (editorId == 0L) return
 
         val currentText = text?.toString() ?: ""
         if (currentText != lastAuthorizedText) return
@@ -921,10 +1080,27 @@ class EditorEditText @JvmOverloads constructor(
      */
     private fun deleteRangeInRust(scalarFrom: Int, scalarTo: Int) {
         if (scalarFrom >= scalarTo) return
+        onDeleteRangeInRustForTesting?.let { callback ->
+            callback(scalarFrom, scalarTo)
+            return
+        }
         val updateJSON = editorDeleteScalarRange(editorId.toULong(), scalarFrom.toUInt(), scalarTo.toUInt())
         applyUpdateJSON(updateJSON)
     }
 
+    private fun deleteBackwardAtSelectionScalarInRust(scalarAnchor: Int, scalarHead: Int) {
+        onDeleteBackwardAtSelectionScalarInRustForTesting?.let { callback ->
+            callback(scalarAnchor, scalarHead)
+            return
+        }
+        val updateJSON = editorDeleteBackwardAtSelectionScalar(
+            editorId.toULong(),
+            scalarAnchor.toUInt(),
+            scalarHead.toUInt()
+        )
+        applyUpdateJSON(updateJSON)
+    }
+
     /**
      * Split a block at a scalar position via the Rust editor.
      */
@@ -1016,6 +1192,244 @@ class EditorEditText @JvmOverloads constructor(
 
     // ── Applying Rust State ─────────────────────────────────────────────
 
+    private fun parseRenderPatch(raw: org.json.JSONObject?): ParsedRenderPatch? {
+        if (raw == null) return null
+        val renderBlocks = raw.optJSONArray("renderBlocks") ?: return null
+        return ParsedRenderPatch(
+            startIndex = raw.optInt("startIndex", -1),
+            deleteCount = raw.optInt("deleteCount", -1),
+            renderBlocks = renderBlocks
+        ).takeIf { it.startIndex >= 0 && it.deleteCount >= 0 }
+    }
+
+    private fun hasTopLevelChildMetadata(content: Spanned): Boolean =
+        content.getSpans(0, content.length, Annotation::class.java).any {
+            it.key == RenderBridge.NATIVE_TOP_LEVEL_CHILD_INDEX_ANNOTATION
+        }
+
+    private fun firstCharacterOffsetForTopLevelChildIndex(content: Spanned, index: Int): Int? {
+        val targetValue = index.toString()
+        return content
+            .getSpans(0, content.length, Annotation::class.java)
+            .asSequence()
+            .filter { it.key == RenderBridge.NATIVE_TOP_LEVEL_CHILD_INDEX_ANNOTATION && it.value == targetValue }
+            .mapNotNull { span ->
+                val spanStart = content.getSpanStart(span)
+                val spanEnd = content.getSpanEnd(span)
+                if (spanStart < 0 || spanEnd <= spanStart) {
+                    null
+                } else {
+                    var candidate = spanStart
+                    while (candidate < spanEnd && candidate < content.length) {
+                        when (content[candidate]) {
+                            '\n', '\r' -> candidate += 1
+                            else -> return@mapNotNull candidate
+                        }
+                    }
+                    null
+                }
+            }
+            .minOrNull()
+    }
+
+    private fun replacementRangeForRenderPatch(
+        content: Spanned,
+        startIndex: Int,
+        deleteCount: Int
+    ): RenderReplaceRange? {
+        val start = firstCharacterOffsetForTopLevelChildIndex(content, startIndex)
+            ?: if (deleteCount == 0) content.length else return null
+        val endExclusive = firstCharacterOffsetForTopLevelChildIndex(content, startIndex + deleteCount)
+            ?: content.length
+        if (start > endExclusive) return null
+        return RenderReplaceRange(start = start, endExclusive = endExclusive)
+    }
+
+    private fun spannedRangeContainsImageSpan(content: Spanned, start: Int, endExclusive: Int): Boolean {
+        if (start >= endExclusive) return false
+        return content.getSpans(start, endExclusive, BlockImageSpan::class.java).isNotEmpty()
+    }
+
+    private fun spannedContainsImageSpan(content: Spanned): Boolean =
+        spannedRangeContainsImageSpan(content, 0, content.length)
+
+    private fun applyRenderedSpannable(
+        spannable: CharSequence,
+        replaceRange: RenderReplaceRange? = null,
+        usedPatch: Boolean
+    ) {
+        isApplyingRustState = true
+        beginBatchEdit()
+        try {
+            if (replaceRange != null) {
+                editableText.replace(replaceRange.start, replaceRange.endExclusive, spannable)
+            } else {
+                setText(spannable)
+            }
+            lastAuthorizedText = text?.toString().orEmpty()
+            lastRenderAppliedPatchForTesting = usedPatch
+        } finally {
+            endBatchEdit()
+            isApplyingRustState = false
+        }
+    }
+
+    private fun buildPatchedSpannable(patch: ParsedRenderPatch): android.text.SpannableStringBuilder =
+        RenderBridge.buildSpannableFromBlocks(
+            patch.renderBlocks,
+            startIndex = patch.startIndex,
+            baseFontSize = baseFontSize,
+            textColor = baseTextColor,
+            theme = theme,
+            density = resources.displayMetrics.density,
+            hostView = this
+        )
+
+    private fun cloneJsonArray(array: org.json.JSONArray): org.json.JSONArray =
+        org.json.JSONArray().also { clone ->
+            for (index in 0 until array.length()) {
+                clone.put(array.opt(index))
+            }
+        }
+
+    private fun normalizedJsonValue(value: Any?): Any? =
+        if (value === org.json.JSONObject.NULL) null else value
+
+    private fun jsonValuesEqual(left: Any?, right: Any?): Boolean {
+        val normalizedLeft = normalizedJsonValue(left)
+        val normalizedRight = normalizedJsonValue(right)
+        if (normalizedLeft === normalizedRight) return true
+        if (normalizedLeft == null || normalizedRight == null) return false
+
+        if (normalizedLeft is org.json.JSONArray && normalizedRight is org.json.JSONArray) {
+            if (normalizedLeft.length() != normalizedRight.length()) return false
+            for (index in 0 until normalizedLeft.length()) {
+                if (!jsonValuesEqual(normalizedLeft.opt(index), normalizedRight.opt(index))) {
+                    return false
+                }
+            }
+            return true
+        }
+
+        if (normalizedLeft is org.json.JSONObject && normalizedRight is org.json.JSONObject) {
+            if (normalizedLeft.length() != normalizedRight.length()) return false
+            val keys = normalizedLeft.keys()
+            while (keys.hasNext()) {
+                val key = keys.next()
+                if (!normalizedRight.has(key)) return false
+                if (!jsonValuesEqual(normalizedLeft.opt(key), normalizedRight.opt(key))) {
+                    return false
+                }
+            }
+            return true
+        }
+
+        if (normalizedLeft is Number && normalizedRight is Number) {
+            return normalizedLeft.toDouble() == normalizedRight.toDouble()
+        }
+
+        return normalizedLeft == normalizedRight
+    }
+
+    private fun renderBlocksEqual(
+        current: org.json.JSONArray,
+        updated: org.json.JSONArray
+    ): Boolean {
+        if (current.length() != updated.length()) return false
+        for (index in 0 until current.length()) {
+            if (!jsonValuesEqual(current.opt(index), updated.opt(index))) {
+                return false
+            }
+        }
+        return true
+    }
+
+    private fun mergeRenderBlocks(
+        current: org.json.JSONArray,
+        patch: ParsedRenderPatch
+    ): org.json.JSONArray? {
+        if (
+            patch.startIndex < 0 ||
+            patch.deleteCount < 0 ||
+            patch.startIndex > current.length() ||
+            patch.startIndex + patch.deleteCount > current.length()
+        ) {
+            return null
+        }
+
+        return org.json.JSONArray().also { merged ->
+            for (index in 0 until patch.startIndex) {
+                merged.put(current.opt(index))
+            }
+            for (index in 0 until patch.renderBlocks.length()) {
+                merged.put(patch.renderBlocks.opt(index))
+            }
+            for (index in (patch.startIndex + patch.deleteCount) until current.length()) {
+                merged.put(current.opt(index))
+            }
+        }
+    }
+
+    private fun applyRenderPatchIfPossible(patch: ParsedRenderPatch): PatchApplyTrace {
+        val eligibilityStartedAt = System.nanoTime()
+        val content = text as? Spanned ?: return PatchApplyTrace(
+            applied = false,
+            eligibilityNanos = System.nanoTime() - eligibilityStartedAt,
+            buildRenderNanos = 0L,
+            applyRenderNanos = 0L
+        )
+        if (!hasTopLevelChildMetadata(content)) {
+            return PatchApplyTrace(
+                applied = false,
+                eligibilityNanos = System.nanoTime() - eligibilityStartedAt,
+                buildRenderNanos = 0L,
+                applyRenderNanos = 0L
+            )
+        }
+
+        val replaceRange = replacementRangeForRenderPatch(content, patch.startIndex, patch.deleteCount)
+            ?: return PatchApplyTrace(
+                applied = false,
+                eligibilityNanos = System.nanoTime() - eligibilityStartedAt,
+                buildRenderNanos = 0L,
+                applyRenderNanos = 0L
+            )
+        if (spannedRangeContainsImageSpan(content, replaceRange.start, replaceRange.endExclusive)) {
+            return PatchApplyTrace(
+                applied = false,
+                eligibilityNanos = System.nanoTime() - eligibilityStartedAt,
+                buildRenderNanos = 0L,
+                applyRenderNanos = 0L
+            )
+        }
+        val eligibilityNanos = System.nanoTime() - eligibilityStartedAt
+
+        val buildStartedAt = System.nanoTime()
+        val patchedSpannable = buildPatchedSpannable(patch)
+        val buildRenderNanos = System.nanoTime() - buildStartedAt
+        if (spannedContainsImageSpan(patchedSpannable)) {
+            return PatchApplyTrace(
+                applied = false,
+                eligibilityNanos = eligibilityNanos,
+                buildRenderNanos = buildRenderNanos,
+                applyRenderNanos = 0L
+            )
+        }
+
+        val applyStartedAt = System.nanoTime()
+        applyRenderedSpannable(
+            spannable = patchedSpannable,
+            replaceRange = replaceRange,
+            usedPatch = true
+        )
+        return PatchApplyTrace(
+            applied = true,
+            eligibilityNanos = eligibilityNanos,
+            buildRenderNanos = buildRenderNanos,
+            applyRenderNanos = System.nanoTime() - applyStartedAt
+        )
+    }
+
     /**
      * Apply a full render update from Rust to the EditText.
      *
@@ -1025,38 +1439,85 @@ class EditorEditText @JvmOverloads constructor(
      * @param updateJSON The JSON string from editor_insert_text, etc.
      */
     fun applyUpdateJSON(updateJSON: String, notifyListener: Boolean = true) {
+        val totalStartedAt = System.nanoTime()
+        val parseStartedAt = totalStartedAt
         val update = try {
             org.json.JSONObject(updateJSON)
         } catch (_: Exception) {
             return
         }
-
-        val renderElements = update.optJSONArray("renderElements") ?: return
-
-        val spannable = RenderBridge.buildSpannableFromArray(
-            renderElements,
-            baseFontSize,
-            baseTextColor,
-            theme,
-            resources.displayMetrics.density,
-            this
-        )
-
+        val parseNanos = System.nanoTime() - parseStartedAt
+
+        val resolveRenderBlocksStartedAt = System.nanoTime()
+        val renderElements = update.optJSONArray("renderElements")
+        val renderBlocks = update.optJSONArray("renderBlocks")
+        val renderPatch = parseRenderPatch(update.optJSONObject("renderPatch"))
+        val resolvedRenderBlocks = renderBlocks
+            ?: renderPatch?.let { patch ->
+                currentRenderBlocksJson?.let { mergeRenderBlocks(it, patch) }
+            }
+        val resolveRenderBlocksNanos = System.nanoTime() - resolveRenderBlocksStartedAt
+        val shouldSkipRender = resolvedRenderBlocks != null &&
+            currentRenderBlocksJson?.let { current ->
+                renderBlocksEqual(current, resolvedRenderBlocks)
+            } == true &&
+            text?.toString() == lastAuthorizedText &&
+            lastAppliedRenderAppearanceRevision == renderAppearanceRevision
         val previousScrollX = scrollX
         val previousScrollY = scrollY
 
         explicitSelectedImageRange = null
-        isApplyingRustState = true
-        setText(spannable)
-        lastAuthorizedText = spannable.toString()
-        isApplyingRustState = false
+        val buildRenderNanos: Long
+        val applyRenderNanos: Long
+        if (shouldSkipRender) {
+            lastRenderAppliedPatchForTesting = false
+            currentRenderBlocksJson = resolvedRenderBlocks?.let(::cloneJsonArray)
+            buildRenderNanos = 0L
+            applyRenderNanos = 0L
+        } else {
+            // Android's Editable.replace(...) path benchmarks substantially slower than
+            // rebuilding from merged render blocks, so patch payloads are treated as a
+            // transport optimization only. We still resolve the merged block state above,
+            // then apply it through the faster full-text path here.
+            val buildStartedAt = System.nanoTime()
+            val fullSpannable = if (resolvedRenderBlocks != null) {
+                RenderBridge.buildSpannableFromBlocks(
+                    resolvedRenderBlocks,
+                    baseFontSize = baseFontSize,
+                    textColor = baseTextColor,
+                    theme = theme,
+                    density = resources.displayMetrics.density,
+                    hostView = this
+                )
+            } else if (renderElements != null) {
+                RenderBridge.buildSpannableFromArray(
+                    renderElements,
+                    baseFontSize,
+                    baseTextColor,
+                    theme,
+                    resources.displayMetrics.density,
+                    this
+                )
+            } else {
+                return
+            }
+            buildRenderNanos = System.nanoTime() - buildStartedAt
+            currentRenderBlocksJson = resolvedRenderBlocks?.let(::cloneJsonArray)
+            val applyStartedAt = System.nanoTime()
+            applyRenderedSpannable(fullSpannable, usedPatch = false)
+            applyRenderNanos = System.nanoTime() - applyStartedAt
+            lastAppliedRenderAppearanceRevision = renderAppearanceRevision
+        }
 
         // Apply the selection from the update.
+        val selectionStartedAt = System.nanoTime()
         val selection = update.optJSONObject("selection")
         if (selection != null) {
             applySelectionFromJSON(selection)
         }
+        val selectionNanos = System.nanoTime() - selectionStartedAt
 
+        val postApplyStartedAt = System.nanoTime()
         if (notifyListener) {
             editorListener?.onEditorUpdate(updateJSON)
         }
@@ -1066,6 +1527,23 @@ class EditorEditText @JvmOverloads constructor(
         } else {
             preserveScrollPosition(previousScrollX, previousScrollY)
         }
+        val postApplyNanos = System.nanoTime() - postApplyStartedAt
+
+        if (captureApplyUpdateTraceForTesting) {
+            lastApplyUpdateTraceForTesting = ApplyUpdateTrace(
+                attemptedPatch = renderPatch != null,
+                usedPatch = false,
+                skippedRender = shouldSkipRender,
+                parseNanos = parseNanos,
+                resolveRenderBlocksNanos = resolveRenderBlocksNanos,
+                patchEligibilityNanos = 0L,
+                buildRenderNanos = buildRenderNanos,
+                applyRenderNanos = applyRenderNanos,
+                selectionNanos = selectionNanos,
+                postApplyNanos = postApplyNanos,
+                totalNanos = System.nanoTime() - totalStartedAt
+            )
+        }
     }
 
     /**
@@ -1090,10 +1568,8 @@ class EditorEditText @JvmOverloads constructor(
         val previousScrollY = scrollY
 
         explicitSelectedImageRange = null
-        isApplyingRustState = true
-        setText(spannable)
-        lastAuthorizedText = spannable.toString()
-        isApplyingRustState = false
+        currentRenderBlocksJson = null
+        applyRenderedSpannable(spannable, usedPatch = false)
         onSelectionOrContentMayChange?.invoke()
         if (heightBehavior == EditorHeightBehavior.AUTO_GROW) {
             requestLayout()