@openeditor/react-native-prose-editor 0.0.6 → 0.0.8

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

@@ -48,11 +48,11 @@ import uniffi.editor_core.*  // UniFFI-generated bindings
  * Instead of letting Android's EditText internal text storage handle insertions
  * and deletions, this class captures the user's intent (typing, deleting,
  * pasting, autocorrect) and sends it to the Rust editor. The Rust editor
- * returns render elements, which are converted to [android.text.SpannableStringBuilder]
- * via [RenderBridge] and applied back to the EditText.
+ * returns a canonical plain-text input snapshot, which is authorized and
+ * applied back to this hidden input adapter.
  *
  * This is the "input interception" pattern: the EditText is effectively
- * a rendering surface, not a text editing engine.
+ * an IME/selection surface, not the visible block renderer.
  *
  * ## Composition Handling
  *
@@ -99,6 +99,7 @@ class EditorEditText @JvmOverloads constructor(
         val rect: RectF
     )
 
+
     data class MentionHit(
         val docPos: Int,
         val label: String
@@ -120,29 +121,11 @@ class EditorEditText @JvmOverloads constructor(
         val text: String
     )
 
-    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
-    )
-
     private data class NativeTextMutation(
         val scalarFrom: Int,
         val scalarTo: Int,
@@ -226,6 +209,7 @@ class EditorEditText @JvmOverloads constructor(
     /** Listener for editor events. */
     var editorListener: EditorListener? = null
     var onSelectionOrContentMayChange: (() -> Unit)? = null
+    var onUpdateJSONApplied: ((String) -> Unit)? = null
 
     /** The base font size in pixels used for unstyled text. */
     private var baseFontSize: Float = textSize
@@ -285,14 +269,12 @@ class EditorEditText @JvmOverloads constructor(
     private var nativeTextMutationAdoptionSuppression: NativeTextMutationAdoptionSuppression? = null
     private var lastAuthorizedTextRevision: Long = 0L
     private var lastAuthorizedRenderedText: CharSequence? = null
-    private var explicitSelectedImageRange: ImageSelectionRange? = null
     private var lastRenderAppliedPatchForTesting: Boolean = false
     internal var captureApplyUpdateTraceForTesting: Boolean = false
     private var lastApplyUpdateTraceForTesting: ApplyUpdateTrace? = null
     private val imeTraceForTesting = java.util.ArrayDeque<String>()
     private var imeTraceSequence: Long = 0L
     private var lastImeTraceUptimeMs: Long = 0L
-    private var currentRenderBlocksJson: org.json.JSONArray? = null
     private var renderAppearanceRevision: Long = 1L
     private var lastAppliedRenderAppearanceRevision: Long = 0L
     private var pendingOptimisticRenderText: String? = null
@@ -401,8 +383,8 @@ class EditorEditText @JvmOverloads constructor(
         linksClickable = false
 
         // Suppress the platform caret and draw our own. Android's Editor anchors
-        // the native caret to getLineBottom(line), which a ParagraphSpacerSpan
-        // inflates — stretching the caret into the inter-block gap. Our caret is
+        // the native caret to getLineBottom(line), which line-height spans can
+        // inflate. Our caret is
         // clipped to the glyph height via [CaretGeometry]. See [drawCustomCaret].
         isCursorVisible = false
 
@@ -642,7 +624,7 @@ class EditorEditText @JvmOverloads constructor(
                 '\\' -> builder.append("\\\\")
                 '"' -> builder.append("\\\"")
                 else -> {
-                    if (ch.code < 0x20 || ch == LayoutConstants.SYNTHETIC_PLACEHOLDER_CHARACTER[0]) {
+                    if (ch.code < 0x20 || ch == InputSnapshotConstants.SYNTHETIC_PLACEHOLDER_CHARACTER[0]) {
                         builder.append("\\u")
                         builder.append(ch.code.toString(16).padStart(4, '0'))
                     } else {
@@ -746,15 +728,6 @@ class EditorEditText @JvmOverloads constructor(
     }
 
     override fun onTouchEvent(event: MotionEvent): Boolean {
-        if (event.actionMasked == MotionEvent.ACTION_DOWN && imageSpanHitAt(event.x, event.y) == null) {
-            clearExplicitSelectedImageRange()
-        }
-        if (handleTaskListMarkerTap(event)) {
-            return true
-        }
-        if (handleImageTap(event)) {
-            return true
-        }
         if (heightBehavior == EditorHeightBehavior.FIXED) {
             val canScroll = canScrollVertically(-1) || canScrollVertically(1)
             if (canScroll) {
@@ -962,9 +935,7 @@ class EditorEditText @JvmOverloads constructor(
     fun setImageResizingEnabled(enabled: Boolean) {
         if (imageResizingEnabled == enabled) return
         imageResizingEnabled = enabled
-        if (!enabled) {
-            clearExplicitSelectedImageRange()
-        } else {
+        if (enabled) {
             onSelectionOrContentMayChange?.invoke()
         }
     }
@@ -1043,8 +1014,8 @@ class EditorEditText @JvmOverloads constructor(
         val selectionOffset = selectionEnd.takeIf { it >= 0 } ?: return null
         val clampedOffset = selectionOffset.coerceIn(0, textLayout.text.length)
         val caretLeft = textLayout.getPrimaryHorizontal(clampedOffset)
-        // Clip the caret to the rendered glyph height so a ParagraphSpacerSpan's
-        // inflated descent does not stretch it into the inter-block gap.
+        // Clip the caret to the rendered glyph height so inflated descent does
+        // not stretch it into extra line space.
         val bounds = CaretGeometry.verticalBounds(textLayout, clampedOffset, paint)
         val left = totalPaddingLeft + caretLeft - scrollX
         val top = totalPaddingTop + bounds.top - scrollY
@@ -1169,8 +1140,6 @@ class EditorEditText @JvmOverloads constructor(
         if (currentText != lastAuthorizedText) return false
         if (startUtf16 < 0 || endUtf16 < startUtf16 || endUtf16 > editable.length) return false
         val spanned = editable as? Spanned
-        if (spanned != null && spannedRangeContainsImageSpan(spanned, startUtf16, endUtf16)) return false
-
         val inlineSpans = spanned?.let {
             optimisticInlineSpansForInsertion(it, startUtf16)
         }.orEmpty()
@@ -1290,6 +1259,32 @@ class EditorEditText @JvmOverloads constructor(
         setCompositionReplacementRange(start, end)
     }
 
+    /** Select the synthetic empty-block scalar so BaseInputConnection replaces
+     * it with transient composing text instead of appending beside it. The
+     * Rust replacement range remains the collapsed 0-width document range. */
+    internal fun selectSyntheticPlaceholderForTransientComposition(): Boolean {
+        val editable = text ?: return false
+        val start = selectionStart
+        val end = selectionEnd
+        if (start < 0 || start != end || start >= editable.length) return false
+        if (editable[start] != EMPTY_BLOCK_PLACEHOLDER) return false
+        Selection.setSelection(editable, start, start + 1)
+        return true
+    }
+
+    internal fun collapseSelectionToComposingEndForEditor() {
+        val editable = text ?: return
+        val composingEnd = BaseInputConnection.getComposingSpanEnd(editable)
+        val replacementStart = composingReplacementStartUtf16
+        val trackedEnd = if (replacementStart != null) {
+            replacementStart + (composingText?.length ?: 0)
+        } else {
+            -1
+        }
+        val end = if (composingEnd >= 0) composingEnd else trackedEnd
+        if (end >= 0) Selection.setSelection(editable, end.coerceIn(0, editable.length))
+    }
+
     internal fun setCompositionReplacementRange(start: Int, end: Int) {
         if (didInvalidateCompositionReplacementRange) return
         val replacementRange = authorizedUtf16Range(start, end)
@@ -1425,8 +1420,22 @@ class EditorEditText @JvmOverloads constructor(
         val currentText = text?.toString() ?: return null
         if (start < 0 || end < start || end > authorizedText.length) return null
 
+        // The input snapshot represents an otherwise empty text block with a
+        // native-only zero-width scalar. Composition at that document position
+        // replaces the scalar visually, while its Rust replacement range stays
+        // collapsed because the scalar is not document content. Exclude it from
+        // the authorized suffix when recovering the transient replacement.
+        val authorizedEnd = if (
+            start == end &&
+            end < authorizedText.length &&
+            authorizedText[end] == EMPTY_BLOCK_PLACEHOLDER
+        ) {
+            end + 1
+        } else {
+            end
+        }
         val authorizedPrefix = authorizedText.substring(0, start)
-        val authorizedSuffix = authorizedText.substring(end)
+        val authorizedSuffix = authorizedText.substring(authorizedEnd)
         if (!currentText.startsWith(authorizedPrefix)) return null
         if (!currentText.endsWith(authorizedSuffix)) return null
 
@@ -2620,10 +2629,6 @@ 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)
-        }
         ensureSelectionVisible()
         onSelectionOrContentMayChange?.invoke()
         // Keep the custom caret solid at its new position, then resume blinking.
@@ -2708,7 +2713,6 @@ class EditorEditText @JvmOverloads constructor(
         lastAuthorizedText = text?.toString().orEmpty()
         lastAuthorizedRenderedText = text?.let { SpannableStringBuilder(it) }
         lastAuthorizedTextRevision += 1L
-        currentRenderBlocksJson = null
         clearNativeTextMutationAdoptionSuppression()
         clearNativeTextMutationAfterBlurWindow()
     }
@@ -3371,7 +3375,7 @@ class EditorEditText @JvmOverloads constructor(
         var effectiveCursor = cursor
         while (
             effectiveCursor > 0 &&
-            content[effectiveCursor - 1] == LayoutConstants.SYNTHETIC_PLACEHOLDER_CHARACTER[0]
+            content[effectiveCursor - 1] == InputSnapshotConstants.SYNTHETIC_PLACEHOLDER_CHARACTER[0]
         ) {
             effectiveCursor -= 1
         }
@@ -3386,7 +3390,7 @@ class EditorEditText @JvmOverloads constructor(
 
     internal fun initialSurroundingTextForImeForEditor(): ImeInitialSurroundingText? {
         val rawText = text?.toString() ?: return null
-        val placeholder = LayoutConstants.SYNTHETIC_PLACEHOLDER_CHARACTER[0]
+        val placeholder = InputSnapshotConstants.SYNTHETIC_PLACEHOLDER_CHARACTER[0]
         if (rawText.indexOf(placeholder) < 0) return null
         val start = selectionStart
         val end = selectionEnd
@@ -3471,14 +3475,14 @@ class EditorEditText @JvmOverloads constructor(
         ch == ' ' ||
             ch == '\t' ||
             ch == '\u00A0' ||
-            ch == LayoutConstants.SYNTHETIC_PLACEHOLDER_CHARACTER[0]
+            ch == InputSnapshotConstants.SYNTHETIC_PLACEHOLDER_CHARACTER[0]
 
     private fun renderedListMarkerEnd(text: String, start: Int, endExclusive: Int): Int? {
         if (start >= endExclusive) return null
         if (renderedTaskListMarkerEnd(text, start, endExclusive) != null) {
             return start + 2
         }
-        if (text[start] == LayoutConstants.UNORDERED_LIST_BULLET[0]) {
+        if (text[start] == InputSnapshotConstants.UNORDERED_LIST_BULLET[0]) {
             return start + 1
         }
 
@@ -3556,48 +3560,7 @@ class EditorEditText @JvmOverloads constructor(
             PositionBridge.utf16ToScalar(snappedHead, currentText)
     }
 
-    fun selectedImageGeometry(): SelectedImageGeometry? {
-        if (!imageResizingEnabled) return null
-        val spannable = text as? Spanned ?: return null
-        val selection = resolvedSelectedImageRange(spannable) ?: return null
-        val start = selection.start
-        val end = selection.end
-        val imageSpan = spannable
-            .getSpans(start, end, BlockImageSpan::class.java)
-            .firstOrNull() ?: return null
-        val spanStart = spannable.getSpanStart(imageSpan)
-        val spanEnd = spannable.getSpanEnd(imageSpan)
-        if (spanStart != start || spanEnd != end) return null
-
-        val textLayout = layout ?: return null
-        val currentText = text?.toString() ?: return null
-        val scalarPos = PositionBridge.utf16ToScalar(spanStart, currentText)
-        val docPos = if (hasLiveEditor()) {
-            editorScalarToDoc(editorId.toULong(), scalarPos.toUInt()).toInt()
-        } else {
-            0
-        }
-        val line = textLayout.getLineForOffset(spanStart.coerceAtMost(maxOf(spannable.length - 1, 0)))
-        val rect = resolvedImageRect(textLayout, imageSpan, spanStart, spanEnd)
-        return SelectedImageGeometry(
-            docPos = docPos,
-            rect = rect
-        )
-    }
 
-    fun resizeImageAtDocPos(docPos: Int, widthPx: Float, heightPx: Float) {
-        if (!hasLiveEditor()) return
-        val density = resources.displayMetrics.density
-        val widthDp = maxOf(48, (widthPx / density).roundToInt())
-        val heightDp = maxOf(48, (heightPx / density).roundToInt())
-        val updateJSON = editorResizeImageAtDocPos(
-            editorId.toULong(),
-            docPos.toUInt(),
-            widthDp.toUInt(),
-            heightDp.toUInt()
-        )
-        applyUpdateJSON(updateJSON)
-    }
 
     private fun isSelectionInsideList(): Boolean {
         if (!hasLiveEditor()) return false
@@ -3636,66 +3599,6 @@ 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,
@@ -3766,167 +3669,11 @@ class EditorEditText @JvmOverloads constructor(
         )
     }
 
-    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.
+     * Apply a structural editor update from Rust to the hidden input EditText.
      *
-     * Parses the update JSON, converts render elements to [android.text.SpannableStringBuilder]
-     * via [RenderBridge], and replaces the EditText's content.
+     * The visible editor surface renders the block tree. This EditText keeps a
+     * plain text snapshot for input, selection, and IME routing only.
      *
      * @param updateJSON The JSON string from editor_insert_text, etc.
      */
@@ -3950,76 +3697,57 @@ class EditorEditText @JvmOverloads constructor(
         cancelDeferredRustUpdateApplication()
         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 = 0L
+        val inputSnapshot = if (update.has("inputText")) update.optString("inputText") else null
+        if (inputSnapshot == null && update.has("selection")) {
+            val selectionStartedAt = System.nanoTime()
+            update.optJSONObject("selection")?.let { applySelectionFromJSON(it) }
+            val selectionNanos = System.nanoTime() - selectionStartedAt
+            if (notifyListener) {
+                editorListener?.onEditorUpdate(updateJSON)
             }
-        val resolveRenderBlocksNanos = System.nanoTime() - resolveRenderBlocksStartedAt
+            onUpdateJSONApplied?.invoke(updateJSON)
+            onSelectionOrContentMayChange?.invoke()
+            recordImeTraceForTesting(
+                "applyUpdateJSON",
+                "notify=$notifyListener selectionOnly=true jsonLength=${updateJSON.length} selectionUs=${nanosToMicros(selectionNanos)}"
+            )
+            return
+        }
         val shouldSkipRender = !refreshInputConnectionForExternalUpdate &&
-            resolvedRenderBlocks != null &&
-            currentRenderBlocksJson?.let { current ->
-                renderBlocksEqual(current, resolvedRenderBlocks)
-            } == true &&
+            inputSnapshot != null &&
+            text?.toString() == inputSnapshot &&
             text?.toString() == lastAuthorizedText &&
             lastAppliedRenderAppearanceRevision == renderAppearanceRevision
         val previousScrollX = scrollX
         val previousScrollY = scrollY
 
-        explicitSelectedImageRange = null
         val buildRenderNanos: Long
         val applyRenderNanos: Long
         if (shouldSkipRender) {
             pendingOptimisticRenderText = null
             lastRenderAppliedPatchForTesting = false
-            currentRenderBlocksJson = resolvedRenderBlocks?.let(::cloneJsonArray)
             clearNativeTextMutationAdoptionSuppression()
             clearNativeTextMutationAfterBlurWindow()
             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 {
+            if (inputSnapshot == null) {
                 recordImeTraceForTesting(
                     "applyUpdateJSONNoop",
-                    "reason=noRenderPayload jsonLength=${updateJSON.length}"
+                    "reason=noRenderTree jsonLength=${updateJSON.length}"
                 )
                 return
             }
+            val fullSpannable = android.text.SpannableStringBuilder(inputSnapshot)
             buildRenderNanos = System.nanoTime() - buildStartedAt
-            currentRenderBlocksJson = resolvedRenderBlocks?.let(::cloneJsonArray)
             val applyStartedAt = System.nanoTime()
             val optimisticText = pendingOptimisticRenderText
             val canReuseOptimisticVisibleText =
                     optimisticText != null &&
                     text?.toString() == optimisticText &&
-                    fullSpannable.toString() == optimisticText &&
-                    !spannedContainsImageSpan(fullSpannable)
+                    fullSpannable.toString() == optimisticText
             if (canReuseOptimisticVisibleText) {
                 authorizeVisibleTextForMatchedOptimisticRender(fullSpannable)
             } else {
@@ -4046,6 +3774,7 @@ class EditorEditText @JvmOverloads constructor(
         if (notifyListener) {
             editorListener?.onEditorUpdate(updateJSON)
         }
+        onUpdateJSONApplied?.invoke(updateJSON)
         onSelectionOrContentMayChange?.invoke()
         if (heightBehavior == EditorHeightBehavior.AUTO_GROW) {
             requestLayout()
@@ -4061,12 +3790,12 @@ class EditorEditText @JvmOverloads constructor(
         val totalNanos = System.nanoTime() - totalStartedAt
         recordImeTraceForTesting(
             "applyUpdateJSON",
-            "notify=$notifyListener skippedRender=$shouldSkipRender attemptedPatch=${renderPatch != null} jsonLength=${updateJSON.length} parseUs=${nanosToMicros(parseNanos)} resolveUs=${nanosToMicros(resolveRenderBlocksNanos)} buildUs=${nanosToMicros(buildRenderNanos)} applyUs=${nanosToMicros(applyRenderNanos)} selectionUs=${nanosToMicros(selectionNanos)} postUs=${nanosToMicros(postApplyNanos)} totalUs=${nanosToMicros(totalNanos)}"
+            "notify=$notifyListener skippedRender=$shouldSkipRender structuralInput=true jsonLength=${updateJSON.length} parseUs=${nanosToMicros(parseNanos)} buildUs=${nanosToMicros(buildRenderNanos)} applyUs=${nanosToMicros(applyRenderNanos)} selectionUs=${nanosToMicros(selectionNanos)} postUs=${nanosToMicros(postApplyNanos)} totalUs=${nanosToMicros(totalNanos)}"
         )
 
         if (captureApplyUpdateTraceForTesting) {
             lastApplyUpdateTraceForTesting = ApplyUpdateTrace(
-                attemptedPatch = renderPatch != null,
+                attemptedPatch = false,
                 usedPatch = false,
                 skippedRender = shouldSkipRender,
                 parseNanos = parseNanos,
@@ -4081,6 +3810,60 @@ class EditorEditText @JvmOverloads constructor(
         }
     }
 
+    private fun plainTextSnapshotFromRenderTree(tree: org.json.JSONObject?): String? {
+        val root = tree?.optJSONObject("root") ?: return null
+        val builder = StringBuilder()
+        appendInputSnapshotNode(root, builder, isRoot = true)
+        return builder.toString()
+    }
+
+    private fun appendInputSnapshotNode(
+        node: org.json.JSONObject,
+        builder: StringBuilder,
+        isRoot: Boolean
+    ) {
+        val kind = node.optString("kind", "block")
+        val nodeType = node.optString("nodeType", "unknown")
+        when (kind) {
+            "text" -> {
+                builder.append(node.optString("text", ""))
+                return
+            }
+            "inlineAtom" -> {
+                if (nodeType == "hardBreak" || nodeType == "hard_break") {
+                    builder.append('\n')
+                } else {
+                    builder.append(node.optString("label", "\uFFFC"))
+                }
+                return
+            }
+            "blockAtom" -> {
+                if (builder.isNotEmpty() && builder.last() != '\n') builder.append('\n')
+                builder.append(node.optString("label", "\uFFFC"))
+                builder.append('\n')
+                return
+            }
+        }
+
+        val children = node.optJSONArray("children") ?: org.json.JSONArray()
+        val startsBlock = !isRoot && isInputSnapshotBlockBoundary(kind)
+        if (startsBlock && builder.isNotEmpty() && builder.last() != '\n') builder.append('\n')
+        for (index in 0 until children.length()) {
+            children.optJSONObject(index)?.let {
+                appendInputSnapshotNode(
+                    it,
+                    builder,
+                    isRoot = false
+                )
+            }
+        }
+        if (startsBlock && builder.isNotEmpty() && builder.last() != '\n') builder.append('\n')
+    }
+
+    private fun isInputSnapshotBlockBoundary(kind: String): Boolean =
+        kind == "textBlock" || kind == "listItem" || kind == "block" ||
+            kind == "tableCell" || kind == "tableRow" || kind == "table"
+
     private fun refreshInputConnectionAfterExternalTextReplacementIfNeeded(
         enabled: Boolean,
         previousVisibleText: String
@@ -4099,44 +3882,6 @@ class EditorEditText @JvmOverloads constructor(
         clearNativeComposingSpans()
     }
 
-    /**
-     * Apply a render JSON string (just render elements, no update wrapper).
-     *
-     * Used for initial content loading (set_html / set_json return render
-     * elements directly, not wrapped in an EditorUpdate).
-     *
-     * @param renderJSON The JSON array string of render elements.
-     */
-    fun applyRenderJSON(renderJSON: String) {
-        val startedAt = System.nanoTime()
-        val spannable = RenderBridge.buildSpannable(
-            renderJSON,
-            baseFontSize,
-            baseTextColor,
-            theme,
-            resources.displayMetrics.density,
-            this
-        )
-
-        val previousScrollX = scrollX
-        val previousScrollY = scrollY
-
-        explicitSelectedImageRange = null
-        currentRenderBlocksJson = null
-        pendingOptimisticRenderText = null
-        applyRenderedSpannable(spannable, usedPatch = false)
-        onSelectionOrContentMayChange?.invoke()
-        if (heightBehavior == EditorHeightBehavior.AUTO_GROW) {
-            requestLayout()
-        } else {
-            preserveScrollPosition(previousScrollX, previousScrollY)
-        }
-        recordImeTraceForTesting(
-            "applyRenderJSON",
-            "jsonLength=${renderJSON.length} totalUs=${nanosToMicros(System.nanoTime() - startedAt)}"
-        )
-    }
-
     private fun textOffsetHitAt(x: Float, y: Float): Pair<Spanned, Int>? {
         val spannable = text as? Spanned ?: return null
         val layout = layout ?: return null
@@ -4160,134 +3905,12 @@ class EditorEditText @JvmOverloads constructor(
         return spannable to offset
     }
 
-    fun mentionHitAt(x: Float, y: Float): MentionHit? {
-        val (spannable, offset) = textOffsetHitAt(x, y) ?: return null
-        val annotations = spannable.getSpans(
-            offset,
-            (offset + 1).coerceAtMost(spannable.length),
-            Annotation::class.java
-        )
-        val mentionAnnotation = annotations.firstOrNull {
-            it.key == "nativeVoidNodeType" && it.value == "mention"
-        } ?: return null
-        val docPos = annotations.firstOrNull { it.key == "nativeDocPos" }
-            ?.value
-            ?.toIntOrNull() ?: return null
-        val start = spannable.getSpanStart(mentionAnnotation)
-        val end = spannable.getSpanEnd(mentionAnnotation)
-        if (start < 0 || end <= start) {
-            return null
-        }
 
-        return MentionHit(
-            docPos = docPos,
-            label = spannable.subSequence(start, end).toString()
-        )
-    }
 
-    fun linkHitAt(x: Float, y: Float): LinkHit? {
-        val (spannable, offset) = textOffsetHitAt(x, y) ?: return null
-        val annotations = spannable.getSpans(
-            offset,
-            (offset + 1).coerceAtMost(spannable.length),
-            Annotation::class.java
-        )
-        val linkAnnotation = annotations.firstOrNull {
-            it.key == RenderBridge.NATIVE_LINK_HREF_ANNOTATION && it.value.isNotBlank()
-        } ?: return null
-        val start = spannable.getSpanStart(linkAnnotation)
-        val end = spannable.getSpanEnd(linkAnnotation)
-        if (start < 0 || end <= start) {
-            return null
-        }
-
-        return LinkHit(
-            href = linkAnnotation.value,
-            text = spannable.subSequence(start, end).toString()
-        )
-    }
-
-    private fun handleImageTap(event: MotionEvent): Boolean {
-        if (!imageResizingEnabled) {
-            return false
-        }
-        if (event.actionMasked != MotionEvent.ACTION_DOWN && event.actionMasked != MotionEvent.ACTION_UP) {
-            return false
-        }
-        val hit = imageSpanHitAt(event.x, event.y) ?: return false
-        requestFocus()
-        selectExplicitImageRange(hit.first, hit.second)
-        if (event.actionMasked == MotionEvent.ACTION_UP) {
-            performClick()
-        }
-        return true
-    }
-
-    private fun handleTaskListMarkerTap(event: MotionEvent): Boolean {
-        if (event.actionMasked != MotionEvent.ACTION_DOWN && event.actionMasked != MotionEvent.ACTION_UP) {
-            return false
-        }
-        val scalarHit = taskListMarkerScalarHitAt(event.x, event.y) ?: return false
-        requestFocus()
-        if (event.actionMasked == MotionEvent.ACTION_UP) {
-            toggleTaskItemCheckedAtSelectionScalarInRust(scalarHit, scalarHit)
-            performClick()
-        }
-        return true
-    }
 
-    private fun taskListMarkerScalarHitAt(x: Float, y: Float): Int? {
-        val currentText = text?.toString() ?: return null
-        val textLayout = layout ?: return null
-        if (currentText.isEmpty()) return null
 
-        val localX = x + scrollX - totalPaddingLeft
-        val localY = y + scrollY - totalPaddingTop
-        if (localY < 0) return null
-
-        val line = textLayout.getLineForVertical(localY.toInt().coerceAtLeast(0))
-        val lineStart = textLayout.getLineStart(line).coerceIn(0, currentText.length)
-        val lineEnd = textLayout.getLineEnd(line).coerceIn(lineStart, currentText.length)
-        val markerEnd = renderedTaskListMarkerEnd(currentText, lineStart, lineEnd) ?: return null
-        val markerRight = textLayout.getPrimaryHorizontal(markerEnd).coerceAtLeast(
-            textLayout.getPrimaryHorizontal(lineStart)
-        ) + (8f * resources.displayMetrics.density)
-        if (localX > markerRight) {
-            return null
-        }
-        val snappedUtf16 = PositionBridge.snapToScalarBoundary(
-            lineStart,
-            currentText,
-            biasForward = true
-        )
-        return PositionBridge.utf16ToScalar(snappedUtf16, currentText)
-    }
 
-    private fun imageSpanHitAt(x: Float, y: Float): Pair<Int, Int>? {
-        val spannable = text as? Spanned ?: return null
-        imageSpanRangeNearTouchOffset(spannable, x, y)?.let { return it }
-        val textLayout = layout ?: return null
-        return imageSpanRectHit(spannable, textLayout, x, y)
-    }
 
-    private fun imageSpanRectHit(
-        spannable: Spanned,
-        textLayout: Layout,
-        x: Float,
-        y: Float
-    ): Pair<Int, Int>? {
-        val candidateSpans = spannable.getSpans(0, spannable.length, BlockImageSpan::class.java)
-        for (span in candidateSpans) {
-            val spanStart = spannable.getSpanStart(span)
-            val spanEnd = spannable.getSpanEnd(span)
-            if (spanStart < 0 || spanEnd <= spanStart) continue
-            val rect = resolvedImageRect(textLayout, span, spanStart, spanEnd)
-            if (rect.contains(x, y)) {
-                return spanStart to spanEnd
-            }
-        }
-        return null
-    }
 
     override fun onFocusChanged(focused: Boolean, direction: Int, previouslyFocusedRect: Rect?) {
         super.onFocusChanged(focused, direction, previouslyFocusedRect)
@@ -4296,7 +3919,6 @@ class EditorEditText @JvmOverloads constructor(
             restartCaretBlink()
         } else {
             beginNativeTextMutationAfterBlurWindow()
-            clearExplicitSelectedImageRange()
             stopCaretBlink()
         }
     }
@@ -4316,92 +3938,11 @@ class EditorEditText @JvmOverloads constructor(
         super.onDetachedFromWindow()
     }
 
-    private fun selectExplicitImageRange(start: Int, end: Int) {
-        explicitSelectedImageRange = ImageSelectionRange(start, end)
-        if (selectionStart == start && selectionEnd == end) {
-            onSelectionOrContentMayChange?.invoke()
-            return
-        }
-        setSelection(start, end)
-    }
-
-    private fun clearExplicitSelectedImageRange() {
-        if (explicitSelectedImageRange == null) return
-        explicitSelectedImageRange = null
-        onSelectionOrContentMayChange?.invoke()
-    }
-
-    private fun resolvedSelectedImageRange(spannable: Spanned): ImageSelectionRange? {
-        explicitSelectedImageRange?.let { explicit ->
-            if (isExactImageSpanRange(spannable, explicit.start, explicit.end)) {
-                return explicit
-            }
-            explicitSelectedImageRange = null
-        }
 
-        val start = selectionStart
-        val end = selectionEnd
-        if (!isExactImageSpanRange(spannable, start, end)) return null
-        return ImageSelectionRange(start, end)
-    }
 
-    private fun isExactImageSpanRange(spannable: Spanned, start: Int, end: Int): Boolean {
-        if (start < 0 || end != start + 1) return false
-        val imageSpan = spannable
-            .getSpans(start, end, BlockImageSpan::class.java)
-            .firstOrNull() ?: return false
-        return spannable.getSpanStart(imageSpan) == start && spannable.getSpanEnd(imageSpan) == end
-    }
 
-    private fun imageSpanRangeNearTouchOffset(
-        spannable: Spanned,
-        x: Float,
-        y: Float
-    ): Pair<Int, Int>? {
-        val safeOffset = runCatching { getOffsetForPosition(x, y) }.getOrNull() ?: return null
-        val nearbyOffsets = linkedSetOf(
-            safeOffset,
-            (safeOffset - 1).coerceAtLeast(0),
-            (safeOffset + 1).coerceAtMost(spannable.length)
-        )
-        for (offset in nearbyOffsets) {
-            val searchStart = (offset - 1).coerceAtLeast(0)
-            val searchEnd = (offset + 1).coerceAtMost(spannable.length)
-            val imageSpan = spannable
-                .getSpans(searchStart, searchEnd, BlockImageSpan::class.java)
-                .firstOrNull() ?: continue
-            val spanStart = spannable.getSpanStart(imageSpan)
-            val spanEnd = spannable.getSpanEnd(imageSpan)
-            if (spanStart >= 0 && spanEnd > spanStart) {
-                return spanStart to spanEnd
-            }
-        }
-        return null
-    }
 
-    private fun resolvedImageRect(
-        textLayout: Layout,
-        imageSpan: BlockImageSpan,
-        spanStart: Int,
-        spanEnd: Int
-    ): RectF {
-        imageSpan.currentDrawRect()?.let { drawnRect ->
-            return drawnRect
-        }
 
-        val safeOffset = spanStart.coerceAtMost(maxOf((text?.length ?: 0) - 1, 0))
-        val line = textLayout.getLineForOffset(safeOffset)
-        val startHorizontal = textLayout.getPrimaryHorizontal(spanStart)
-        val endHorizontal = textLayout.getPrimaryHorizontal(spanEnd)
-        val (widthPx, heightPx) = imageSpan.currentSizePx()
-        val left = compoundPaddingLeft + minOf(startHorizontal, endHorizontal)
-        val right = compoundPaddingLeft + maxOf(
-            maxOf(startHorizontal, endHorizontal),
-            minOf(startHorizontal, endHorizontal) + widthPx
-        )
-        val top = extendedPaddingTop + textLayout.getLineBottom(line) - heightPx
-        return RectF(left, top.toFloat(), right, top + heightPx.toFloat())
-    }
 
     /**
      * Apply a selection from a parsed JSON selection object.