@apollohg/react-native-rich-text-editor 2.0.1 → 2.0.3

package/README.md

@@ -4,19 +4,19 @@
 
 See the [documentation](https://github.com/apollohg/react-native-rich-text-editor/wiki) for guides and API references. The package is under active development; review the [changelog](./CHANGELOG.md) before upgrading between major versions.
 
-<img src="https://github.com/apollohg/react-native-rich-text-editor/wiki/images/github-banner.png" alt="Example editor on iOS" width="100%" />
+<a href="./assets/github-demo-banner.mp4"><img src="./assets/github-demo-banner.gif" alt="Native iOS editor demo with rich text, nested lists, a code block, and image resizing" width="100%" /></a>
 
 ## Highlights
 
-- Native iOS and Android editing backed by a Rust document engine
-- HTML and ProseMirror JSON input and output
-- Configurable schemas, marks, blockquotes, lists, links, images, and mentions
-- Custom atom nodes rendered with your React components
-- Native toolbar, theming, selection, undo, and redo
-- `RichTextViewer`, an exact-size Fabric renderer for read-only content
-- Shared document handles for local editing and Yjs collaboration
-
-`NativeRichTextEditor` and `NativeProseViewer`, along with their associated types, remain available as deprecated aliases of `RichTextEditor` and `RichTextViewer`.
+**⭐ Native editing on iOS and Android**  
+**⭐ Built-in Yjs collaboration**  
+**⭐ React Native components inside documents**  
+**⭐ External text composition**  
+**⭐ Dedicated Fabric viewer**  
+**⭐ Configurable document schemas** with HTML and ProseMirror JSON import/export  
+**⭐ Nested bullet and numbered lists**  
+**⭐ Optional native code syntax highlighting**  
+**⭐ Rich copy and paste**  
 
 ## Requirements
 
@@ -50,7 +50,7 @@ npx expo prebuild
 npx expo run:ios       # or: npx expo run:android
 ```
 
-See the [Installation Guide](https://github.com/apollohg/react-native-rich-text-editor/wiki/Installation) for bare React Native setup and migration from `@apollohg/react-native-prose-editor`.
+See the [Installation Guide](https://github.com/apollohg/react-native-rich-text-editor/wiki/Installation) for bare React Native setup.
 
 ## Editor usage
 
@@ -89,9 +89,21 @@ export function EditorScreen() {
 
 See [Getting Started](https://github.com/apollohg/react-native-rich-text-editor/wiki/Getting-Started) and the [RichTextEditor reference](https://github.com/apollohg/react-native-rich-text-editor/wiki/RichTextEditor-Reference) for the complete API.
 
+## Copy and paste
+
+Copy and cut publish an editor fragment, HTML, and plain text. Pasting between compatible editor schemas preserves selected marks, nodes, and atom attributes. External rich text imports supported HTML formatting and structure, with RTF conversion on iOS.
+
+Use `pasteMode` to control native clipboard paste:
+
+```tsx
+<RichTextEditor documentHandle={documentHandle} pasteMode="plainText" />
+```
+
+The default is `"rich"`. `"plainText"` removes source formatting and atoms, while retaining the destination's ordinary typing marks. `"disabled"` blocks paste without disabling copy or typing. Changes apply immediately. These settings govern clipboard actions; programmatic insertion and drag/drop retain their own behaviour. Unsupported external formatting is reduced to supported content, and clipboard images do not trigger uploads.
+
 ## Custom atom nodes
 
-Render interactive cards, embeds, and other custom blocks with your own React components. Define an atom with `defineAtomNode`, add it to your document schema, and pass it through the editor or viewer's `atoms` prop.
+Render interactive cards, embeds, and other custom blocks with your own React components.
 
 See [Custom Atom Nodes](https://github.com/apollohg/react-native-rich-text-editor/wiki/Custom-Atom-Nodes) for a complete example and API details.
 
@@ -107,108 +119,13 @@ import { RichTextViewer } from '@apollohg/react-native-rich-text-editor';
 
 See the [Viewer Guide](https://github.com/apollohg/react-native-rich-text-editor/wiki/Viewer) for styling, images, interactions, and custom atoms.
 
-## Element styling and addons
-
-Version 2 uses a flat, typed stylesheet for both the editor and viewer:
-
-```tsx
-import { EditorStyleSheet, RichTextEditor } from '@apollohg/react-native-rich-text-editor';
-
-const theme = EditorStyleSheet.create({
-    content: { padding: 16, backgroundColor: '#ffffff' },
-    text: { fontSize: 16, color: '#202124' },
-    paragraph: { marginBottom: 12 },
-    link: { color: '#285dcc', textDecorationLine: 'underline' },
-    blockquote: {
-        backgroundColor: '#f3f5f8',
-        padding: 12,
-        borderWidth: 1,
-        borderColor: '#dce1e8',
-        borderLeftWidth: 4,
-        borderLeftColor: '#285dcc',
-        borderTopRightRadius: 8,
-    },
-    codeBlock: { backgroundColor: '#eff1f5', padding: 12, borderRadius: 8 },
-    image: { backgroundColor: '#eff1f5', borderRadius: 12, resizeMode: 'cover' },
-});
-
-<RichTextEditor documentHandle={documentHandle} theme={theme} />;
-```
-
-Each entry accepts a style object or nested, conditional style arrays. Later entries override earlier properties; explicit `undefined` removes an earlier property. Side and corner properties override shorthands. Supported fields are checked by TypeScript and validated before native updates. These are editor styles: layout fields such as `flex`, transforms, and positioning are not accepted.
-
-Text styling inherits from `text` and enclosing blocks. Backgrounds, spacing, borders, and corner radii belong to each element. Inline entries support typography and backgrounds; mentions also support borders. List containers, items, markers, and checkboxes have separate entries. `toolbar` retains its existing configuration.
-
-Android editing uses per-block text layout for physical margins, borders, and padding, including RTL content. Per-block justification is supported on Android API 26+; API 24/25 use normal alignment.
-
-Custom atom components mount inside Android's native scrolling content. Their measured height participates in document layout, and their controls receive normal React Native touch events.
+## Styling and addons
 
-Addons are a readonly array. Conditional `false`, `null`, and `undefined` entries are allowed; duplicate capabilities are rejected:
-
-```tsx
-import { createMentionsAddon } from '@apollohg/react-native-rich-text-editor';
-import { createCodeHighlightingAddon } from '@apollohg/react-native-rich-text-editor-code-highlighting';
-
-<RichTextEditor
-    documentHandle={documentHandle}
-    theme={theme}
-    addons={[
-        createMentionsAddon({ trigger: '@', suggestions }),
-        enableHighlighting && createCodeHighlightingAddon({ theme: 'base16-ocean.dark' }),
-    ]}
-/>;
-```
-
-Syntax highlighting requires the separately installed [code-highlighting package](./packages/code-highlighting), followed by a native rebuild. The base editor does not include syntect or its grammars. Set a code block's `attrs.language`, for example `{ type: 'codeBlock', attrs: { language: 'typescript' }, content: [...] }`. Missing or unsupported languages keep ordinary code styling. The code block theme controls the panel; the highlighting addon controls token colors and font traits. Mention-enabled editor handles still require `withMentionsSchema` when creating their schema.
-
-When migrating from version 1, replace `links` with `link`, heading maps with `h1`–`h6`, `spacingAfter` with `marginBottom`, and `contentInsets` with `content.padding*`. Flatten nested quote/code typography into their element entry, and move list appearance into the relevant container/item/marker entries. Addon objects become `[createMentionsAddon(options)]`. The new built-in schema declares code-block language metadata; coordinate schema changes across collaborating clients.
+Customize the editor and viewer with themes, mentions, and syntax highlighting. See [Styling](https://github.com/apollohg/react-native-rich-text-editor/wiki/Styling) and [Addons](https://github.com/apollohg/react-native-rich-text-editor/wiki/Addons).
 
 ## Collaboration
 
-`useYjsCollaboration` connects a room-backed document handle to a Yjs sync and awareness server. The editor and collaboration controller must share the same handle.
-
-```tsx
-import React, { useEffect, useMemo } from 'react';
-import {
-    createNativeEditorDocumentHandle,
-    RichTextEditor,
-    useYjsCollaboration,
-} from '@apollohg/react-native-rich-text-editor';
-
-export function CollaborativeEditor({ documentId }: { documentId: string }) {
-    const documentHandle = useMemo(
-        () =>
-            createNativeEditorDocumentHandle({
-                initialization: {
-                    type: 'room',
-                    documentId,
-                    lineageId: `my-app|${documentId}`,
-                },
-            }),
-        [documentId]
-    );
-
-    const collaboration = useYjsCollaboration({
-        documentId,
-        handle: documentHandle,
-        transport: {
-            url: `wss://example.com/collaboration?documentId=${encodeURIComponent(documentId)}`,
-            connect: true,
-        },
-        localAwareness: {
-            userId: 'user-1',
-            name: 'Ada',
-            color: '#0A84FF',
-        },
-    });
-
-    useEffect(() => () => documentHandle.destroy(), [documentHandle]);
-
-    return <RichTextEditor {...collaboration.editorBindings} />;
-}
-```
-
-See the [Collaboration Guide](https://github.com/apollohg/react-native-rich-text-editor/wiki/Collaboration) for server requirements, persistence, authentication, and recovery.
+Connect shared documents to a Yjs server for collaborative editing and live cursors. See the [Collaboration Guide](https://github.com/apollohg/react-native-rich-text-editor/wiki/Collaboration).
 
 ## Comparison with other React Native editors
 
@@ -225,14 +142,6 @@ Reviewed on 7 September 2026
 
 ## Development
 
-Run `npm run lint:kotlin` to check Kotlin style or `npm run format:kotlin` to
-apply automatic fixes. Both commands use ktlint 1.8.0 with Android Studio style
-and four-space indentation. Java 17+ is required (`JAVA_HOME` or `java` on PATH).
-The first run downloads and verifies the CLI into `.tmp/ktlint`; subsequent runs
-use the cached copy. Generated bindings, build output, dependencies, and Expo's
-generated native projects are excluded. Additional ktlint options can be passed
-after `--`, for example `npm run lint:kotlin -- --reporter=plain-summary`.
-
 See the [example app](./example) to try the editor and viewer, and the [Development Workflow](https://github.com/apollohg/react-native-rich-text-editor/wiki/Development-Workflow) for local setup, native builds, and testing.
 
 ## Documentation
@@ -248,12 +157,9 @@ See the [example app](./example) to try the editor and viewer, and the [Developm
 - [Mentions](https://github.com/apollohg/react-native-rich-text-editor/wiki/Mentions)
 - [Styling](https://github.com/apollohg/react-native-rich-text-editor/wiki/Styling)
 - [Production limits and errors](https://github.com/apollohg/react-native-rich-text-editor/wiki/Production-Limits-and-Errors)
+- [Migration guide](https://github.com/apollohg/react-native-rich-text-editor/wiki/Migration-Guide)
 - [Changelog](./CHANGELOG.md)
 
 ## License
 
-[Apache-2.0](./LICENSE) for this project's own code. Dependencies retain their respective licenses.
-
-[Third-party notices](./THIRD_PARTY_NOTICES.md) cover the bundled Rust libraries, native dependencies, and copied icon assets; [Rust standard-library notices](./RUST-STANDARD-LIBRARY-NOTICES.html) accompany the prebuilt native libraries. The optional highlighting package ships its own notices for syntect, grammars, themes, and its other dependencies.
-
-When distributing an app, include the applicable notices with the app's open-source acknowledgements or other accompanying materials, including the MPL corresponding-source links. Retain notices for the actual React Native/Expo and native dependency versions resolved by your app as well. An npm package's notices are not automatically copied into the final app by Metro. Refresh notices when dependencies, bundled assets, or the Rust toolchain change.
+[Apache-2.0](./LICENSE). See [third-party notices](./THIRD_PARTY_NOTICES.md) and [Rust standard-library notices](./RUST-STANDARD-LIBRARY-NOTICES.html) for bundled dependencies.

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

@@ -133,6 +133,8 @@ class EditorEditText @JvmOverloads constructor(
             }
         }
 
+    internal var pasteMode: EditorPasteMode = EditorPasteMode.RICH
+
     /**
      * Guard flag to prevent re-entrant input interception while we're
      * applying state from Rust (calling [setText] or modifying text storage).
@@ -245,6 +247,7 @@ class EditorEditText @JvmOverloads constructor(
     internal var currentRenderBlocksNeedFullApply = false
     internal var authorizedVisibleTextNeedsRebuild = false
     internal var logicalSelectionSnapshot: LogicalSelectionSnapshot? = null
+    internal var authoritativeNodeSelectionRange: ImageSelectionRange? = null
     internal var lastAllowedAtomCaretSelection: Pair<Int, Int>? = null
     private var localTextDrag: LocalTextDrag? = null
     internal var lastAppliedDocumentVersion: String? = null
@@ -275,6 +278,7 @@ class EditorEditText @JvmOverloads constructor(
     internal var onSetSelectionScalarInRustForTesting: ((Int, Int) -> Unit)? = null
     internal var onDeleteAndSplitScalarInRustForTesting: ((Int, Int) -> Unit)? = null
     internal var onInsertContentHtmlInRustForTesting: ((String) -> Unit)? = null
+    internal var onSetPrimaryClipForTesting: ((android.content.ClipData) -> Unit)? = null
     internal var onResizeImageAtDocPosForTesting: ((Int, Int, Int) -> Unit)? = null
     internal var onMoveSelectionScalarForTesting: ((Int, Int, Int) -> Unit)? = null
     internal var onBeforeRenderRefresh: (() -> Unit)? = null
@@ -788,14 +792,18 @@ class EditorEditText @JvmOverloads constructor(
 
     fun performToolbarRedo() = performToolbarRedoImpl()
 
-    /**
-     * Intercept paste operations to route content through Rust.
-     *
-     * Attempts to extract HTML from the clipboard first (for rich text paste),
-     * falling back to plain text.
-     */
+    /** Routes native clipboard actions through the authoritative Rust selection. */
     override fun onTextContextMenuItem(id: Int): Boolean {
+        if (id == android.R.id.copy) {
+            handleCopy()
+            return true
+        }
         if (!isEditable && isMutatingContextMenuItem(id)) return true
+        if (pasteMode == EditorPasteMode.DISABLED &&
+            (id == android.R.id.paste || id == android.R.id.pasteAsPlainText)
+        ) {
+            return true
+        }
         if (id == android.R.id.cut) {
             handleCut()
             return true
@@ -812,6 +820,11 @@ class EditorEditText @JvmOverloads constructor(
      * Selection and copy actions remain available.
      */
     override fun performAccessibilityAction(action: Int, arguments: android.os.Bundle?): Boolean {
+        if (pasteMode == EditorPasteMode.DISABLED &&
+            action == android.view.accessibility.AccessibilityNodeInfo.ACTION_PASTE
+        ) {
+            return false
+        }
         if (!isEditable && (
                 action == android.view.accessibility.AccessibilityNodeInfo.ACTION_SET_TEXT ||
                     action == android.view.accessibility.AccessibilityNodeInfo.ACTION_PASTE ||
@@ -842,6 +855,7 @@ class EditorEditText @JvmOverloads constructor(
         }
         ensureSelectionVisible()
         if (isApplyingRustState) return
+        authoritativeNodeSelectionRange = null
         val wasExternallyComposing = externalTextComposition != null
         if (!commitExternalTextCompositionBeforeInteractionIfNeeded()) return
         if (wasExternallyComposing) {

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

@@ -1,9 +1,94 @@
 package com.apollohg.editor
 
 import android.content.ClipData
+import android.content.ClipDescription
 import android.content.ClipboardManager
 import android.content.Context
-import android.view.accessibility.AccessibilityNodeInfo
+import android.os.PersistableBundle
+import org.json.JSONObject
+
+internal enum class EditorPasteMode {
+    RICH,
+    PLAIN_TEXT,
+    DISABLED;
+
+    companion object {
+        fun fromRaw(value: String?): EditorPasteMode = when (value) {
+            "plainText" -> PLAIN_TEXT
+            "disabled" -> DISABLED
+            else -> RICH
+        }
+    }
+}
+
+internal data class EditorClipboardPayload(
+    val fragment: String? = null,
+    val html: String? = null,
+    val text: String? = null
+)
+
+internal object EditorClipboard {
+    const val MIME_TYPE_FRAGMENT = "application/vnd.apollohg.native-editor.fragment+json"
+    const val EXTRA_FRAGMENT = "com.apollohg.editor.clipboard.FRAGMENT"
+
+    fun fromExportJson(json: String): EditorClipboardPayload? = try {
+        val value = JSONObject(json)
+        if (value.optBoolean("empty", false)) {
+            null
+        } else {
+            val fragment = value.optString("fragment").takeIf { it.isNotEmpty() }
+            val html = value.optString("html").takeIf { it.isNotEmpty() }
+            val text = value.optString("text").takeIf { it.isNotEmpty() }
+            if (fragment == null && html == null && text == null) {
+                null
+            } else {
+                EditorClipboardPayload(fragment, html, text)
+            }
+        }
+    } catch (_: Exception) {
+        null
+    }
+
+    fun create(payload: EditorClipboardPayload): ClipData {
+        val mimeTypes = buildList {
+            if (payload.html != null) add(ClipDescription.MIMETYPE_TEXT_HTML)
+            add(ClipDescription.MIMETYPE_TEXT_PLAIN)
+            if (payload.fragment != null) add(MIME_TYPE_FRAGMENT)
+        }.distinct().toTypedArray()
+        val description = ClipDescription("rich text", mimeTypes)
+        payload.fragment?.let { fragment ->
+            description.extras = PersistableBundle().apply {
+                putString(EXTRA_FRAGMENT, fragment)
+            }
+        }
+        return ClipData(
+            description,
+            ClipData.Item(payload.text ?: "", payload.html, null, null)
+        )
+    }
+
+    fun read(clip: ClipData, context: Context): EditorClipboardPayload {
+        if (clip.itemCount == 0) return EditorClipboardPayload()
+        val item = clip.getItemAt(0)
+        val hasPrivateMime = (0 until clip.description.mimeTypeCount).any {
+            clip.description.getMimeType(it) == MIME_TYPE_FRAGMENT
+        }
+        val fragment = if (hasPrivateMime) {
+            runCatching {
+                clip.description.extras?.getString(EXTRA_FRAGMENT)
+            }.getOrNull()
+        } else {
+            null
+        }
+        return EditorClipboardPayload(
+            fragment = fragment,
+            html = item.htmlText,
+            text = item.text?.toString() ?: runCatching {
+                item.coerceToText(context)?.toString()
+            }.getOrNull()
+        )
+    }
+}
 
 internal fun EditorEditText.isMutatingContextMenuItem(id: Int): Boolean =
     id == android.R.id.paste ||
@@ -14,16 +99,37 @@ internal fun EditorEditText.prepareForExternalInteractionMutation(): Boolean =
     commitExternalTextCompositionBeforeInteractionIfNeeded() &&
         prepareForExternalEditorUpdate()
 
-internal fun EditorEditText.handlePaste(plainTextOnly: Boolean) {
-    val selectionRange = normalizedUtf16SelectionRange()
-    if (selectionRange != null &&
-        isCollapsedAtomBoundarySelection(selectionRange.first, selectionRange.second)
-    ) {
-        return
+internal fun EditorEditText.publishClipboard(payload: EditorClipboardPayload): Boolean {
+    return try {
+        val clip = EditorClipboard.create(payload)
+        val testWriter = onSetPrimaryClipForTesting
+        if (testWriter != null) {
+            testWriter(clip)
+        } else {
+            val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager
+                ?: return false
+            clipboard.setPrimaryClip(clip)
+        }
+        true
+    } catch (_: Exception) {
+        false
     }
+}
+
+internal fun EditorEditText.handleCopy(): Boolean {
+    if (editorId == 0L || v2Driver == null) return baseTextContextMenuItem(android.R.id.copy)
+    if (discardTransientInputForDestroyedEditorIfNeeded()) return false
+    if (!prepareForExternalInteractionMutation()) return false
+    syncCurrentSelectionToRust()
+    val payload = v2Driver?.clipboardJson()?.let(EditorClipboard::fromExportJson) ?: return false
+    return publishClipboard(payload)
+}
+
+internal fun EditorEditText.handlePaste(plainTextOnly: Boolean) {
+    val forcePlainText = plainTextOnly || pasteMode == EditorPasteMode.PLAIN_TEXT
     if (editorId == 0L) {
         baseTextContextMenuItem(
-            if (plainTextOnly) android.R.id.pasteAsPlainText else android.R.id.paste
+            if (forcePlainText) android.R.id.pasteAsPlainText else android.R.id.paste
         )
         return
     }
@@ -32,21 +138,40 @@ internal fun EditorEditText.handlePaste(plainTextOnly: Boolean) {
 
     val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager
         ?: return
-    val clip = clipboard.primaryClip ?: return
-    if (clip.itemCount == 0) return
-
-    val item = clip.getItemAt(0)
+    val clip = runCatching { clipboard.primaryClip }.getOrNull() ?: return
+    val payload = EditorClipboard.read(clip, context)
+    if (payload.fragment == null && payload.html == null && payload.text.isNullOrEmpty()) return
 
-    val htmlText = item.htmlText
-    if (!plainTextOnly && htmlText != null) {
-        pasteHTML(htmlText)
+    if (payload.fragment == null && payload.html == null &&
+        (onInsertTextInRustForTesting != null || onReplaceTextInRustForTesting != null)
+    ) {
+        payload.text?.let(::pastePlainText)
         return
     }
-
-    val plainText = item.text?.toString() ?: item.coerceToText(context)?.toString()
-    if (plainText != null) {
-        pastePlainText(plainText)
+    val driver = v2Driver
+    if (driver == null) {
+        if (forcePlainText) {
+            payload.text?.let(::pastePlainText)
+        } else if (payload.html != null) {
+            pasteHTML(payload.html)
+        } else {
+            payload.text?.let(::pastePlainText)
+        }
+        return
     }
+    val (anchor, head) = currentScalarSelection() ?: return
+    val preserveEngineSelection = authoritativeNodeSelectionRange?.let { range ->
+        selectionStart == range.start && selectionEnd == range.end
+    } == true
+    driver.pasteAtSelection(
+        fragment = payload.fragment,
+        html = payload.html,
+        text = payload.text,
+        plainText = forcePlainText,
+        anchor = anchor,
+        head = head,
+        preserveEngineSelection = preserveEngineSelection
+    )?.let { applyUpdateJSON(it) }
 }
 
 internal fun EditorEditText.handleCut() {
@@ -56,25 +181,45 @@ internal fun EditorEditText.handleCut() {
     }
     if (discardTransientInputForDestroyedEditorIfNeeded()) return
     if (!prepareForExternalInteractionMutation()) return
+    if (v2Driver == null) {
+        val currentText = text?.toString() ?: return
+        val (selectionStart, selectionEnd) = normalizedUtf16SelectionRange(currentText) ?: return
+        val (utf16Start, utf16End) = PositionBridge.snapRangeToScalarBoundaries(
+            selectionStart,
+            selectionEnd,
+            currentText
+        )
+        if (utf16Start >= utf16End) return
+        val selectedText = currentText.substring(utf16Start, utf16End)
+        if (!publishClipboard(EditorClipboardPayload(text = selectedText))) return
+        deleteRangeInRust(
+            PositionBridge.utf16ToScalar(utf16Start, currentText),
+            PositionBridge.utf16ToScalar(utf16End, currentText)
+        )
+        return
+    }
+    syncCurrentSelectionToRust()
 
-    val currentText = text?.toString() ?: return
-    val (selectionStart, selectionEnd) = normalizedUtf16SelectionRange(currentText) ?: return
-    if (selectionStart == selectionEnd) return
-
-    val (utf16Start, utf16End) = PositionBridge.snapRangeToScalarBoundaries(
-        selectionStart,
-        selectionEnd,
-        currentText
-    )
-    if (utf16Start >= utf16End) return
-
-    val selectedText = currentText.substring(utf16Start, utf16End)
-    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager
-    clipboard?.setPrimaryClip(ClipData.newPlainText(null, selectedText))
+    val payload = v2Driver?.clipboardJson()?.let(EditorClipboard::fromExportJson) ?: return
+    if (!publishClipboard(payload)) return
 
-    val scalarStart = PositionBridge.utf16ToScalar(utf16Start, currentText)
-    val scalarEnd = PositionBridge.utf16ToScalar(utf16End, currentText)
-    deleteRangeInRust(scalarStart, scalarEnd)
+    val (anchor, head) = currentScalarSelection() ?: return
+    if (onDeleteRangeInRustForTesting != null) {
+        deleteRangeInRust(minOf(anchor, head), maxOf(anchor, head))
+        return
+    }
+    val preserveEngineSelection = authoritativeNodeSelectionRange?.let { range ->
+        selectionStart == range.start && selectionEnd == range.end
+    } == true
+    v2Driver?.pasteAtSelection(
+        fragment = null,
+        html = null,
+        text = "",
+        plainText = true,
+        anchor = anchor,
+        head = head,
+        preserveEngineSelection = preserveEngineSelection
+    )?.let { applyUpdateJSON(it) }
 }
 
 internal fun EditorEditText.handleAccessibilitySetText(arguments: android.os.Bundle?): Boolean {

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

@@ -76,6 +76,31 @@ internal fun EditorEditText.selectedImageGeometryImpl(): SelectedImageGeometry?
     )
 }
 
+internal fun EditorEditText.selectedImageSpanForResize(): BlockImageSpan? {
+    val spannable = text as? Spanned ?: return null
+    val selection = resolvedSelectedImageRange(spannable) ?: return null
+    return spannable.getSpans(
+        selection.start,
+        selection.end,
+        BlockImageSpan::class.java
+    ).firstOrNull { span ->
+        spannable.getSpanStart(span) == selection.start &&
+            spannable.getSpanEnd(span) == selection.end
+    }
+}
+
+internal fun EditorEditText.relayoutImageResizePreview(span: BlockImageSpan) {
+    val content = text ?: return
+    val start = content.getSpanStart(span)
+    val end = content.getSpanEnd(span)
+    if (start < 0 || end <= start) return
+    val flags = content.getSpanFlags(span)
+    content.setSpan(span, start, end, flags)
+    requestLayout()
+    invalidate()
+    onContentSizeMayChange?.invoke()
+}
+
 internal fun EditorEditText.resizeImageAtDocPosImpl(docPos: Int, widthPx: Float, heightPx: Float) {
     if (!hasLiveEditor()) return
     val density = resources.displayMetrics.density

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

@@ -100,6 +100,10 @@ internal fun EditorEditText.canonicalListCaretOffset(selStart: Int, selEnd: Int)
 
 internal fun EditorEditText.syncCurrentSelectionToRust() {
     if (!hasLiveEditor()) return
+    authoritativeNodeSelectionRange?.let { range ->
+        if (selectionStart == range.start && selectionEnd == range.end) return
+        authoritativeNodeSelectionRange = null
+    }
 
     val currentText = text?.toString() ?: ""
     if (currentText != lastAuthorizedText) return
@@ -296,6 +300,7 @@ internal fun EditorEditText.applySelectionFromJSON(
         val currentText = text?.toString() ?: ""
         when (type) {
             "text" -> {
+                authoritativeNodeSelectionRange = null
                 val docAnchor = exactV2ScalarInt(selection.opt("anchor") as? Number) ?: return
                 val docHead = exactV2ScalarInt(selection.opt("head") as? Number) ?: return
                 // The frozen v2 update includes exact scalar positions alongside its
@@ -339,10 +344,12 @@ internal fun EditorEditText.applySelectionFromJSON(
                 val clamped = startUtf16.coerceIn(0, len)
                 val endClamped = (clamped + 1).coerceAtMost(len)
                 setSelection(clamped, endClamped)
+                authoritativeNodeSelectionRange = ImageSelectionRange(clamped, endClamped)
             }
 
             "all" -> {
                 logicalSelectionSnapshot = null
+                authoritativeNodeSelectionRange = null
                 selectAll()
             }
         }

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

@@ -391,21 +391,30 @@ internal class EditorTextSurfaceInteraction(
                         0,
                         android.R.string.copy
                     ).setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM)
-                    if ((view as? EditorEditText)?.isEditable != false) {
+                    val editor = view as? EditorEditText
+                    if (editor?.isEditable != false) {
                         menu.add(
                             0,
                             android.R.id.cut,
                             1,
                             android.R.string.cut
                         ).setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM)
-                        menu.add(
-                            0,
-                            android.R.id.paste,
-                            2,
-                            android.R.string.paste
-                        ).setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM)
+                        if (editor?.pasteMode != EditorPasteMode.DISABLED) {
+                            menu.add(
+                                0,
+                                android.R.id.paste,
+                                2,
+                                android.R.string.paste
+                            ).setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM)
+                            menu.add(
+                                0,
+                                android.R.id.pasteAsPlainText,
+                                3,
+                                android.R.string.paste_as_plain_text
+                            )
+                        }
                     }
-                    menu.add(0, android.R.id.selectAll, 3, android.R.string.selectAll)
+                    menu.add(0, android.R.id.selectAll, 4, android.R.string.selectAll)
                     return true
                 }
                 override fun onPrepareActionMode(mode: ActionMode, menu: Menu) = false
@@ -457,12 +466,20 @@ internal class EditorTextSurfaceInteraction(
     }
 
     fun onKeyDown(keyCode: Int, event: KeyEvent): Boolean {
-        if (event.isCtrlPressed) {
+        if (event.isCtrlPressed || event.isMetaPressed) {
             val action = when (keyCode) {
                 KeyEvent.KEYCODE_A -> android.R.id.selectAll
+
                 KeyEvent.KEYCODE_C -> android.R.id.copy
+
                 KeyEvent.KEYCODE_X -> android.R.id.cut
-                KeyEvent.KEYCODE_V -> android.R.id.paste
+
+                KeyEvent.KEYCODE_V -> if (event.isShiftPressed) {
+                    android.R.id.pasteAsPlainText
+                } else {
+                    android.R.id.paste
+                }
+
                 else -> 0
             }
             if (action != 0) return view.onTextContextMenuItem(action)
@@ -559,10 +576,13 @@ internal class EditorTextSurfaceInteraction(
         info.addAction(AccessibilityNodeInfo.ACTION_NEXT_AT_MOVEMENT_GRANULARITY)
         info.addAction(AccessibilityNodeInfo.ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY)
         info.addAction(AccessibilityNodeInfo.ACTION_COPY)
+        val editor = view as? EditorEditText
         if (info.isEditable) {
             info.addAction(AccessibilityNodeInfo.ACTION_SET_TEXT)
             info.addAction(AccessibilityNodeInfo.ACTION_CUT)
-            info.addAction(AccessibilityNodeInfo.ACTION_PASTE)
+            if (editor?.pasteMode != EditorPasteMode.DISABLED) {
+                info.addAction(AccessibilityNodeInfo.ACTION_PASTE)
+            }
         }
     }