@apollohg/react-native-rich-text-editor 2.0.0

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

@@ -0,0 +1,327 @@
+package com.apollohg.editor
+
+import android.os.Handler
+import android.os.Looper
+import android.text.SpannableStringBuilder
+import com.apollohg.editor.EditorEditText.AuthoritativeInputSnapshot
+import org.json.JSONObject
+
+// Samsung Keyboard may call finishComposingText() and then commitText(" ")
+// for one space tap. Defer the render from finishComposingText() by one
+// loop so setText() does not restart input before the pending space arrives.
+internal fun EditorEditText.runWithDeferredRustUpdateApplicationImpl(block: () -> Unit) {
+    recordImeTraceForTesting(
+        "deferRustUpdateBegin",
+        "depth=$deferredRustUpdateApplicationDepth pending=${deferredRustUpdateJSON != null}"
+    )
+    deferredRustUpdateApplicationDepth += 1
+    try {
+        block()
+    } finally {
+        deferredRustUpdateApplicationDepth -= 1
+        recordImeTraceForTesting(
+            "deferRustUpdateEnd",
+            "depth=$deferredRustUpdateApplicationDepth pending=${deferredRustUpdateJSON != null}"
+        )
+        if (deferredRustUpdateApplicationDepth == 0) {
+            scheduleDeferredRustUpdateApplication()
+        }
+    }
+}
+
+internal fun EditorEditText.applyRustUpdateJSON(
+    updateJSON: String,
+    lineBoundaryRefreshSource: String? = null
+) {
+    if (externalUpdatePreparationCaptureDepth > 0) {
+        capturedExternalUpdatePreparationJSON = updateJSON
+        // Keep the visible IME commit authorized until the external view
+        // consumes this exact adapter-adopted snapshot below.
+        authorizeCurrentVisibleTextForDeferredRustUpdate()
+        recordImeTraceForTesting(
+            "rustUpdateCapturedForExternalPreflight",
+            "jsonLength=${updateJSON.length} depth=$externalUpdatePreparationCaptureDepth"
+        )
+        return
+    }
+    if (deferredRustUpdateApplicationDepth > 0) {
+        if (deferredRustUpdateJSON != null && deferredRustUpdateJSON != updateJSON) {
+            advanceRenderBlocksThroughDeferredUpdate(deferredRustUpdateJSON!!)
+        }
+        deferredRustUpdateJSON = updateJSON
+        deferredRustUpdateLineBoundaryRefreshSource = lineBoundaryRefreshSource
+        recordImeTraceForTesting(
+            "rustUpdateDeferred",
+            "jsonLength=${updateJSON.length} depth=$deferredRustUpdateApplicationDepth"
+        )
+        authorizeCurrentVisibleTextForDeferredRustUpdate()
+        return
+    }
+    recordImeTraceForTesting(
+        "rustUpdateApply",
+        "mode=immediate jsonLength=${updateJSON.length}"
+    )
+    if (applyUpdateJSON(updateJSON)) {
+        lineBoundaryRefreshSource?.let(::scheduleLineBoundaryInputRefreshForEditor)
+    }
+}
+
+internal fun EditorEditText.authorizeCurrentVisibleTextForDeferredRustUpdate() {
+    val visibleText = text?.toString().orEmpty()
+    if (visibleText != lastAuthorizedText) {
+        authorizedVisibleTextNeedsRebuild = true
+    }
+    lastAuthorizedText = visibleText
+    lastAuthorizedRenderedText = text?.let { SpannableStringBuilder(it) }
+    lastAuthorizedTextRevision += 1L
+    clearNativeTextMutationAdoptionSuppression()
+    clearNativeTextMutationAfterBlurWindow()
+}
+
+internal fun EditorEditText.authorizeCurrentVisibleTextForPendingImeOperationForEditorImpl(
+    logicalCursorAfter: Int? = null
+) {
+    pendingOptimisticRenderText = null
+    authorizeCurrentVisibleTextForDeferredRustUpdate()
+    if (logicalCursorAfter != null) {
+        rememberLogicalSelection(
+            scalarAnchor = logicalCursorAfter,
+            scalarHead = logicalCursorAfter,
+            utf16Anchor = selectionStart,
+            utf16Head = selectionEnd,
+            documentVersion = null
+        )
+    }
+    recordImeTraceForTesting(
+        "authorizePendingImeVisibleText",
+        "textLength=${lastAuthorizedText.length}"
+    )
+}
+
+internal fun EditorEditText.captureAuthoritativeInputSnapshotImpl(): AuthoritativeInputSnapshot =
+    AuthoritativeInputSnapshot(
+        renderedText = SpannableStringBuilder(lastAuthorizedRenderedText ?: lastAuthorizedText),
+        selectionStart = selectionStart.coerceAtLeast(0),
+        selectionEnd = selectionEnd.coerceAtLeast(0)
+    )
+
+internal fun EditorEditText.deleteScalarRangeForPendingImeOperationForEditorImpl(
+    scalarFrom: Int,
+    scalarTo: Int
+): EditorV2NativeIntentResult? {
+    onDeleteRangeInRustForTesting?.let { callback ->
+        runWithDeferredRustUpdateApplication {
+            callback(scalarFrom, scalarTo)
+        }
+        return null
+    }
+    return v2Driver?.deleteScalarRangeNative(scalarFrom, scalarTo)
+}
+
+internal fun EditorEditText.promoteOptimisticInputForEditorImpl(
+    render: EditorV2NativeMutationRender,
+    logicalCursorAfter: Int
+) {
+    authorizeCurrentVisibleTextForPendingImeOperationForEditor(logicalCursorAfter)
+    pendingOptimisticRenderText = text?.toString()
+    applyRustUpdateJSON(render.updateJson)
+}
+
+internal fun EditorEditText.restoreAuthoritativeInputForEditorImpl(
+    snapshot: AuthoritativeInputSnapshot,
+    recoveryUpdateJson: String? = null
+) {
+    pendingOptimisticRenderText = null
+    cancelDeferredRustUpdateApplication()
+    if (recoveryUpdateJson != null) {
+        if (applyUpdateJSON(recoveryUpdateJson, notifyListener = false)) return
+    }
+    val wasApplyingRustState = isApplyingRustState
+    isApplyingRustState = true
+    beginBatchEdit()
+    try {
+        setText(snapshot.renderedText)
+        val length = text?.length ?: 0
+        setSelection(
+            snapshot.selectionStart.coerceIn(0, length),
+            snapshot.selectionEnd.coerceIn(0, length)
+        )
+    } finally {
+        endBatchEdit()
+        isApplyingRustState = wasApplyingRustState
+    }
+}
+
+internal fun EditorEditText.handleStructuralBackspaceImpl() {
+    if (!isEditable || isApplyingRustState) return
+    if (editorId == 0L) {
+        handleBackspace()
+        return
+    }
+    if (discardTransientInputForDestroyedEditorIfNeeded()) return
+    val currentText = text?.toString() ?: return
+    val (anchor, head) = currentLogicalScalarSelection()
+        ?: normalizedScalarSelectionRange(currentText)
+        ?: return
+    onDeleteBackwardAtSelectionScalarInRustForTesting?.let { callback ->
+        callback(anchor, head)
+        return
+    }
+    v2Driver?.let { driver ->
+        if (selectAtomBeforeEmptyTrailingParagraph(driver)) return
+        val updateJSON = driver.deleteBackwardAtSelection(anchor, head)
+        applyNonOptimisticRustUpdate(driver, updateJSON)
+    }
+}
+
+internal fun EditorEditText.selectAtomBeforeEmptyTrailingParagraph(
+    driver: EditorV2Driver
+): Boolean {
+    val adapter = driver as? EditorV2Adapter ?: return false
+    val content = text ?: return false
+    if (selectionStart != selectionEnd) return false
+    val raw = content.toString()
+    val paragraphStart = raw.lastIndexOf('\n') + 1
+    if (paragraphStart < 2 || selectionEnd < paragraphStart) return false
+    val trailingText = raw.substring(paragraphStart)
+    if (trailingText.isNotEmpty() &&
+        trailingText != LayoutConstants.SYNTHETIC_PLACEHOLDER_CHARACTER
+    ) {
+        return false
+    }
+    val atom = content.getSpans(paragraphStart - 2, paragraphStart - 1, AtomBlockSpan::class.java)
+        .firstOrNull { content.getSpanEnd(it) == paragraphStart - 1 } ?: return false
+    deferredRustUpdateJSON?.let { applyUpdateJSON(it) }
+    adapter.selectAtomNode(atom.docPos)?.let {
+        applyUpdateJSON(it, notifyListener = false)
+        editorListener?.onSelectionChanged(atom.docPos, atom.docPos + 1)
+    }
+    return true
+}
+
+internal fun EditorEditText.handleStructuralDeleteImpl(
+    utf16From: Int,
+    utf16To: Int,
+    scalarFrom: Int,
+    scalarTo: Int
+) {
+    if (!isEditable || isApplyingRustState || scalarFrom >= scalarTo) return
+    if (editorId == 0L) {
+        text?.delete(utf16From, utf16To)
+        return
+    }
+    if (discardTransientInputForDestroyedEditorIfNeeded()) return
+    onDeleteRangeInRustForTesting?.let { callback ->
+        callback(scalarFrom, scalarTo)
+        return
+    }
+    v2Driver?.let { driver ->
+        val updateJSON = driver.deleteScalarRange(scalarFrom, scalarTo)
+        applyNonOptimisticRustUpdate(driver, updateJSON)
+    }
+}
+
+internal fun EditorEditText.applyNonOptimisticRustUpdate(
+    driver: EditorV2Driver,
+    updateJSON: String?
+) {
+    if (driver is EditorV2Adapter) {
+        driver.recoverNativeRender()?.let { applyRustUpdateJSON(it) }
+        return
+    }
+    updateJSON?.let { applyRustUpdateJSON(it) }
+}
+
+internal fun EditorEditText.committedTokenRangeAroundMutation(
+    currentText: String,
+    replacementStartUtf16: Int,
+    replacementEndUtf16: Int
+): Pair<Int, Int>? {
+    if (currentText.isEmpty()) return null
+    val start = replacementStartUtf16.coerceIn(0, currentText.length)
+    val end = replacementEndUtf16.coerceIn(start, currentText.length)
+    val probe = when {
+        start < end -> start
+        start < currentText.length -> start
+        start > 0 -> Character.offsetByCodePoints(currentText, start, -1)
+        else -> return null
+    }
+    val tokenRange = missingOldTextCorrectionTokenRangeForEditor(currentText, probe) ?: return null
+    return if (start < end) {
+        tokenRange.takeIf { it.first <= start && it.second >= end }
+    } else {
+        tokenRange.takeIf { start >= it.first && start <= it.second }
+    }
+}
+
+internal fun EditorEditText.scheduleDeferredRustUpdateApplication() {
+    val pendingUpdateJSON = deferredRustUpdateJSON ?: return
+    val pendingLineBoundaryRefreshSource = deferredRustUpdateLineBoundaryRefreshSource
+    val generation = ++deferredRustUpdateGeneration
+    recordImeTraceForTesting(
+        "rustUpdateDeferredScheduled",
+        "generation=$generation jsonLength=${pendingUpdateJSON.length}"
+    )
+    Handler(Looper.getMainLooper()).post {
+        if (generation != deferredRustUpdateGeneration) {
+            recordImeTraceForTesting(
+                "rustUpdateDeferredSkip",
+                "reason=generation generation=$generation current=$deferredRustUpdateGeneration"
+            )
+            return@post
+        }
+        if (deferredRustUpdateJSON != pendingUpdateJSON) {
+            recordImeTraceForTesting(
+                "rustUpdateDeferredSkip",
+                "reason=replaced generation=$generation"
+            )
+            return@post
+        }
+        deferredRustUpdateJSON = null
+        deferredRustUpdateLineBoundaryRefreshSource = null
+        recordImeTraceForTesting(
+            "rustUpdateApply",
+            "mode=deferred generation=$generation jsonLength=${pendingUpdateJSON.length}"
+        )
+        if (applyUpdateJSON(pendingUpdateJSON)) {
+            pendingLineBoundaryRefreshSource?.let(::scheduleLineBoundaryInputRefreshForEditor)
+        }
+    }
+}
+
+internal fun EditorEditText.advanceRenderBlocksThroughDeferredUpdate(updateJSON: String) {
+    val update = try {
+        org.json.JSONObject(updateJSON)
+    } catch (_: Exception) {
+        invalidateCurrentRenderBlocks()
+        return
+    }
+    val updateDocumentVersion = canonicalV2U64(update.opt("documentVersion") as? String)
+    val renderBlocks = update.optJSONArray("renderBlocks")
+    val patch = parseRenderPatch(update.optJSONObject("renderPatch"))
+    val resolved = renderBlocks
+        ?: patch?.takeIf { patchMatchesCurrentRenderBlocks(it, updateDocumentVersion) }?.let {
+            currentRenderBlocksJson?.let { current -> mergeRenderBlocks(current, it) }
+        }
+    retainCurrentRenderBlocks(
+        resolved,
+        updateDocumentVersion,
+        needFullApply = resolved != null
+    )
+}
+
+internal fun EditorEditText.cancelDeferredRustUpdateApplication(
+    invalidateRenderBlocks: Boolean = true
+) {
+    if (deferredRustUpdateJSON == null) return
+    recordImeTraceForTesting(
+        "rustUpdateDeferredCancel",
+        "generation=$deferredRustUpdateGeneration"
+    )
+    deferredRustUpdateJSON = null
+    deferredRustUpdateLineBoundaryRefreshSource = null
+    deferredRustUpdateGeneration += 1L
+    if (invalidateRenderBlocks) {
+        invalidateCurrentRenderBlocks()
+    }
+}

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

@@ -0,0 +1,258 @@
+package com.apollohg.editor
+
+import com.apollohg.editor.EditorEditText.Companion.EMPTY_BLOCK_PLACEHOLDER
+
+/**
+ * Handle surrounding text deletion from the IME.
+ *
+ * Called by [EditorInputConnection.deleteSurroundingText].
+ *
+ * @param beforeLength Number of UTF-16 code units to delete before the cursor.
+ * @param afterLength Number of UTF-16 code units to delete after the cursor.
+ */
+internal fun EditorEditText.handleDeleteImpl(beforeLength: Int, afterLength: Int) {
+    if (!isEditable) return
+    if (isApplyingRustState) return
+    val selectionRange = normalizedUtf16SelectionRange()
+    if (selectionRange != null &&
+        isCollapsedAtomBoundarySelection(selectionRange.first, selectionRange.second)
+    ) {
+        return
+    }
+    if (editorId == 0L) {
+        val editable = this.text ?: return
+        val (selectionStart, selectionEnd) = selectionRange ?: return
+        val delStart: Int
+        val delEnd: Int
+        if (selectionStart != selectionEnd) {
+            delStart = selectionStart
+            delEnd = selectionEnd
+        } else {
+            delStart = maxOf(0, selectionStart - beforeLength.coerceAtLeast(0))
+            delEnd = minOf(editable.length, selectionStart + afterLength.coerceAtLeast(0))
+        }
+        editable.delete(delStart, delEnd)
+        return
+    }
+    if (discardTransientInputForDestroyedEditorIfNeeded()) return
+
+    val currentText = text?.toString() ?: ""
+    val (selectionStart, selectionEnd) = selectionRange ?: return
+    if (selectionStart != selectionEnd) {
+        val (scalarStart, scalarEnd) = normalizedScalarSelectionRange(currentText) ?: return
+        deleteRangeInRust(scalarStart, scalarEnd)
+        return
+    }
+    val cursor = selectionStart
+    if (beforeLength > 0 &&
+        afterLength == 0 &&
+        cursor > 0 &&
+        currentText.getOrNull(cursor - 1) == EMPTY_BLOCK_PLACEHOLDER
+    ) {
+        val scalarCursor = PositionBridge.utf16ToScalar(cursor, currentText)
+        deleteBackwardAtSelectionScalarInRust(scalarCursor, scalarCursor)
+        return
+    }
+    val rawDelStart = maxOf(0, cursor - beforeLength.coerceAtLeast(0))
+    val rawDelEnd = minOf(currentText.length, cursor + afterLength.coerceAtLeast(0))
+    val (delStart, delEnd) = PositionBridge.snapRangeToScalarBoundaries(
+        rawDelStart,
+        rawDelEnd,
+        currentText
+    )
+
+    val scalarStart = PositionBridge.utf16ToScalar(delStart, currentText)
+    val scalarEnd = PositionBridge.utf16ToScalar(delEnd, currentText)
+
+    if (scalarStart < scalarEnd) {
+        deleteRangeInRust(scalarStart, scalarEnd)
+    } else if (beforeLength > 0 && afterLength == 0) {
+        deleteBackwardAtSelectionScalarInRust(scalarEnd, scalarEnd)
+    }
+}
+
+/**
+ * Handle backspace key press (hardware keyboard or key event).
+ *
+ * If there's a range selection, deletes the range. Otherwise deletes
+ * the grapheme cluster before the cursor.
+ */
+internal fun EditorEditText.handleBackspaceImpl() {
+    if (!isEditable) return
+    if (isApplyingRustState) return
+    val selectionRange = normalizedUtf16SelectionRange() ?: return
+    if (isCollapsedAtomBoundarySelection(selectionRange.first, selectionRange.second)) return
+    if (editorId == 0L) {
+        val editable = this.text ?: return
+        val (start, end) = selectionRange
+        if (start != end) {
+            editable.delete(start, end)
+        } else if (start > 0) {
+            val prevBoundary = PositionBridge.snapToGraphemeBoundary(
+                start - 1,
+                text?.toString() ?: ""
+            )
+            val adjustedPrev = if (prevBoundary >= start) maxOf(0, start - 1) else prevBoundary
+            editable.delete(adjustedPrev, start)
+        }
+        return
+    }
+    if (discardTransientInputForDestroyedEditorIfNeeded()) return
+
+    val currentText = text?.toString() ?: ""
+    val (start, end) = selectionRange
+    val logicalSelection = currentLogicalScalarSelection()
+
+    if (start != end) {
+        val (scalarStart, scalarEnd) = normalizedScalarSelectionRange(currentText) ?: return
+        deleteRangeInRust(scalarStart, scalarEnd)
+    } else if (logicalSelection != null && logicalSelection.first == logicalSelection.second) {
+        deleteBackwardAtSelectionScalarInRust(logicalSelection.first, logicalSelection.second)
+    } else if (start > 0) {
+        if (currentText.getOrNull(start - 1) == EMPTY_BLOCK_PLACEHOLDER) {
+            val scalarCursor = PositionBridge.utf16ToScalar(start, 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()
+        breakIter.setText(currentText)
+        val prevBoundary = breakIter.preceding(start)
+        val prevUtf16 = if (prevBoundary == java.text.BreakIterator.DONE) 0 else prevBoundary
+
+        val scalarStart = PositionBridge.utf16ToScalar(prevUtf16, currentText)
+        val scalarEnd = PositionBridge.utf16ToScalar(start, currentText)
+        if (scalarStart < scalarEnd) {
+            deleteRangeInRust(scalarStart, scalarEnd)
+        } else {
+            deleteBackwardAtSelectionScalarInRust(scalarEnd, scalarEnd)
+        }
+    } else {
+        deleteBackwardAtSelectionScalarInRust(0, 0)
+    }
+}
+
+internal fun EditorEditText.handleForwardDeleteImpl() {
+    if (!isEditable) return
+    if (isApplyingRustState) return
+    val selectionRange = normalizedUtf16SelectionRange() ?: return
+    if (isCollapsedAtomBoundarySelection(selectionRange.first, selectionRange.second)) return
+    if (editorId == 0L) {
+        val editable = this.text ?: return
+        val (start, end) = selectionRange
+        if (start != end) {
+            editable.delete(start, end)
+        } else if (start < editable.length) {
+            val breakIter = java.text.BreakIterator.getCharacterInstance()
+            breakIter.setText(editable.toString())
+            val nextBoundary = breakIter.following(start)
+            val nextUtf16 = if (nextBoundary == java.text.BreakIterator.DONE) {
+                editable.length
+            } else {
+                nextBoundary
+            }
+            editable.delete(start, nextUtf16.coerceIn(start, editable.length))
+        }
+        return
+    }
+    if (discardTransientInputForDestroyedEditorIfNeeded()) return
+
+    val currentText = text?.toString() ?: ""
+    val (start, end) = selectionRange
+    if (start != end) {
+        val (scalarStart, scalarEnd) = normalizedScalarSelectionRange(currentText) ?: return
+        deleteRangeInRust(scalarStart, scalarEnd)
+    } else if (start < currentText.length) {
+        val breakIter = java.text.BreakIterator.getCharacterInstance()
+        breakIter.setText(currentText)
+        val nextBoundary = breakIter.following(start)
+        val nextUtf16 = if (nextBoundary == java.text.BreakIterator.DONE) {
+            currentText.length
+        } else {
+            nextBoundary
+        }
+        val (utf16Start, utf16End) = PositionBridge.snapRangeToScalarBoundaries(
+            start,
+            nextUtf16.coerceIn(start, currentText.length),
+            currentText
+        )
+        val scalarStart = PositionBridge.utf16ToScalar(utf16Start, currentText)
+        val scalarEnd = PositionBridge.utf16ToScalar(utf16End, currentText)
+        if (scalarStart < scalarEnd) {
+            deleteRangeInRust(scalarStart, scalarEnd)
+        }
+    }
+}
+
+/**
+ * Handle return/enter key as a block split operation.
+ */
+internal fun EditorEditText.handleReturnKeyImpl() {
+    if (!isEditable) return
+    if (isApplyingRustState) return
+
+    val currentText = text?.toString() ?: ""
+    val (start, end) = normalizedUtf16SelectionRange() ?: return
+    if (isCollapsedAtomBoundarySelection(start, end)) return
+
+    if (editorId == 0L) {
+        val editable = this.text ?: return
+        editable.replace(start, end, "\n")
+        return
+    }
+    if (discardTransientInputForDestroyedEditorIfNeeded()) return
+
+    val (scalarStart, scalarEnd) = normalizedScalarSelectionRange(currentText) ?: return
+    if (scalarStart != scalarEnd) {
+        deleteAndSplitInRust(scalarStart, scalarEnd)
+    } else {
+        splitBlockInRust(scalarEnd)
+    }
+}
+
+/**
+ * Handle Shift+Enter as an inline hard break insertion.
+ */
+internal fun EditorEditText.handleHardBreakImpl() {
+    if (!isEditable) return
+    if (isApplyingRustState) return
+    if (isCollapsedAtomBoundarySelection(selectionStart, selectionEnd)) return
+
+    if (editorId == 0L) {
+        val editable = this.text ?: return
+        val start = selectionStart
+        val end = selectionEnd
+        editable.replace(start, end, "\n")
+        return
+    }
+    if (discardTransientInputForDestroyedEditorIfNeeded()) return
+
+    val selection = currentScalarSelection() ?: return
+    v2Driver?.let { driver ->
+        driver.insertNode(preferredHardBreakNodeType(), selection.first, selection.second)?.let {
+            applyUpdateJSON(it)
+        }
+    }
+}
+
+/**
+ * Handle hardware Tab / Shift+Tab as list indent / outdent when the caret is in a list.
+ */
+internal fun EditorEditText.handleTabImpl(shiftPressed: Boolean): Boolean {
+    if (!isEditable) return false
+    if (isApplyingRustState) return false
+    if (!hasLiveEditor()) return false
+    if (!isSelectionInsideList()) return false
+    val selection = currentScalarSelection() ?: return false
+
+    v2Driver?.let { driver ->
+        val update = if (shiftPressed) {
+            driver.outdentListItem(selection.first, selection.second)
+        } else {
+            driver.indentListItem(selection.first, selection.second)
+        }
+        update?.let { applyUpdateJSON(it) }
+    }
+    return true
+}

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

@@ -0,0 +1,83 @@
+package com.apollohg.editor
+
+import android.os.SystemClock
+import android.util.Log
+import com.apollohg.editor.EditorEditText.ApplyUpdateTrace
+import com.apollohg.editor.EditorEditText.Companion.IME_TRACE_LIMIT_FOR_TESTING
+import com.apollohg.editor.EditorEditText.Companion.IME_TRACE_LOG_TAG
+
+internal fun EditorEditText.ownsNativeBindingImpl(adapter: EditorV2Adapter): Boolean =
+    adapter.isNativeBindingOwner(nativeBindingToken)
+
+internal fun EditorEditText.lastRenderAppliedPatchImpl(): Boolean = lastRenderAppliedPatchForTesting
+
+internal fun EditorEditText.lastApplyUpdateTraceImpl(): ApplyUpdateTrace? =
+    lastApplyUpdateTraceForTesting
+
+internal fun EditorEditText.hasDeferredRustUpdateApplicationForTestingImpl(): Boolean =
+    deferredRustUpdateJSON != null
+
+internal fun EditorEditText.inputConnectionGenerationForTestingImpl(): Long =
+    inputConnectionGeneration
+
+internal fun EditorEditText.authorizedTextForTestingImpl(): String = lastAuthorizedText
+
+internal fun EditorEditText.applyRustUpdateJSONForTestingImpl(updateJSON: String) {
+    applyRustUpdateJSON(updateJSON)
+}
+
+internal fun EditorEditText.recordImeTraceForTestingImpl(event: String, details: String = "") {
+    if (imeTraceForTesting.size >= IME_TRACE_LIMIT_FOR_TESTING) {
+        imeTraceForTesting.removeFirst()
+    }
+    imeTraceForTesting.addLast(
+        if (details.isEmpty()) event else "$event:$details"
+    )
+    if (Log.isLoggable(IME_TRACE_LOG_TAG, Log.VERBOSE)) {
+        val now = SystemClock.uptimeMillis()
+        val deltaMs = if (lastImeTraceUptimeMs == 0L) 0L else now - lastImeTraceUptimeMs
+        lastImeTraceUptimeMs = now
+        imeTraceSequence += 1L
+        val textLength = text?.length ?: -1
+        val selection = "$selectionStart..$selectionEnd"
+        val composingRange = "${composingReplacementStartUtf16 ?: -1}.." +
+            "${composingReplacementEndUtf16 ?: -1}"
+        val composingRevisionMatches =
+            composingReplacementAuthorizedTextRevision == lastAuthorizedTextRevision
+        val message = buildString {
+            append("#").append(imeTraceSequence)
+            append(" +").append(deltaMs).append("ms ")
+            append(event)
+            if (details.isNotEmpty()) {
+                append(" ").append(details)
+            }
+            append(" editor=").append(editorId)
+            append(" gen=").append(inputConnectionGeneration)
+            append(" activeIc=").append(activeInputConnection != null)
+            append(" focus=").append(hasFocus())
+            append(" applying=").append(isApplyingRustState)
+            append(" editable=").append(isEditable)
+            append(" textLen=").append(textLength)
+            append(" authLen=").append(lastAuthorizedText.length)
+            append(" sel=").append(selection)
+            append(" composingTextLen=").append(composingText?.length ?: -1)
+            append(" composingRange=").append(composingRange)
+            append(" composingRevOk=").append(composingRevisionMatches)
+            append(" invalidComp=").append(didInvalidateCompositionReplacementRange)
+            append(" deferredRustUpdate=").append(deferredRustUpdateJSON != null)
+            append(" scroll=").append(scrollX).append(",").append(scrollY)
+        }
+        Log.v(IME_TRACE_LOG_TAG, message)
+    }
+}
+
+internal fun EditorEditText.clearImeTraceForTestingImpl() {
+    imeTraceForTesting.clear()
+    imeTraceSequence = 0L
+    lastImeTraceUptimeMs = 0L
+}
+
+internal fun EditorEditText.imeTraceSnapshotForTestingImpl(): List<String> =
+    imeTraceForTesting.toList()
+
+internal fun EditorEditText.nanosToMicros(nanos: Long): Long = nanos / 1_000L