react-native-enriched-markdown-scaffold 0.7.4-scaffold.8 → 1.0.2-scaffold.1

package/android/src/main/java/com/swmansion/enriched/markdown/input/EnrichedMarkdownTextInputView.kt

@@ -1,6 +1,5 @@
 package com.swmansion.enriched.markdown.input
 
-import android.content.ClipData
 import android.content.ClipboardManager
 import android.content.Context
 import android.graphics.BlendMode
@@ -20,6 +19,9 @@ import android.view.inputmethod.EditorInfo
 import android.view.inputmethod.InputConnection
 import android.view.inputmethod.InputMethodManager
 import androidx.appcompat.widget.AppCompatEditText
+import androidx.core.view.ContentInfoCompat
+import androidx.core.view.OnReceiveContentListener
+import androidx.core.view.ViewCompat
 import com.facebook.react.common.ReactConstants
 import com.facebook.react.uimanager.BackgroundStyleApplicator
 import com.facebook.react.uimanager.PixelUtil
@@ -28,45 +30,55 @@ import com.facebook.react.views.text.ReactTypefaceUtils
 import com.swmansion.enriched.markdown.input.autolink.AutoLinkDetector
 import com.swmansion.enriched.markdown.input.autolink.LinkRegexConfig
 import com.swmansion.enriched.markdown.input.detection.DetectorPipeline
-import com.swmansion.enriched.markdown.input.detection.WordsUtils
+import com.swmansion.enriched.markdown.input.editing.BlockEditCoordinator
+import com.swmansion.enriched.markdown.input.editing.ClipboardCoordinator
+import com.swmansion.enriched.markdown.input.editing.EditContext
+import com.swmansion.enriched.markdown.input.editing.EditPhase
+import com.swmansion.enriched.markdown.input.editing.EditPipeline
+import com.swmansion.enriched.markdown.input.editing.EditPipelineHost
+import com.swmansion.enriched.markdown.input.editing.EditSession
 import com.swmansion.enriched.markdown.input.editing.InputConnectionWrapper
+import com.swmansion.enriched.markdown.input.editing.LinkCoordinator
 import com.swmansion.enriched.markdown.input.editing.MarkdownEditableFactory
 import com.swmansion.enriched.markdown.input.editing.MarkdownTextWatcher
+import com.swmansion.enriched.markdown.input.editing.MentionCoordinator
+import com.swmansion.enriched.markdown.input.editing.MentionEvent
+import com.swmansion.enriched.markdown.input.editing.ZWSP
+import com.swmansion.enriched.markdown.input.editing.isLineBreak
+import com.swmansion.enriched.markdown.input.formatting.BlockStore
 import com.swmansion.enriched.markdown.input.formatting.FormattingStore
 import com.swmansion.enriched.markdown.input.formatting.InputFormatter
 import com.swmansion.enriched.markdown.input.formatting.InputParser
 import com.swmansion.enriched.markdown.input.layout.InputEventEmitter
 import com.swmansion.enriched.markdown.input.layout.InputLayoutManager
 import com.swmansion.enriched.markdown.input.math.MathChipController
+import com.swmansion.enriched.markdown.input.model.BlockRange
+import com.swmansion.enriched.markdown.input.model.BlockType
 import com.swmansion.enriched.markdown.input.model.FormattingRange
 import com.swmansion.enriched.markdown.input.model.InputFormatterStyle
+import com.swmansion.enriched.markdown.input.model.MathAtom
 import com.swmansion.enriched.markdown.input.model.MathChipStyle
+import com.swmansion.enriched.markdown.input.model.OBJECT_REPLACEMENT
 import com.swmansion.enriched.markdown.input.model.StyleType
 import com.swmansion.enriched.markdown.input.toolbar.InputContextMenu
 import com.swmansion.enriched.markdown.utils.input.AutoCapitalizeUtils
+import com.swmansion.enriched.markdown.utils.input.PasteTextUtils
 import kotlin.math.ceil
 
-private fun Char.isLineBreak(): Boolean = this == '\n' || this == '\r' || this == '\u0085' || this == '\u2028' || this == '\u2029'
-
 class EnrichedMarkdownTextInputView(
   context: Context,
 ) : AppCompatEditText(context) {
   private var isComponentReady = false
 
   val formattingStore = FormattingStore()
-  val formatter = InputFormatter()
+  val blockStore = BlockStore()
+  val formatter = InputFormatter(resources.displayMetrics.density)
   val pendingStyles = mutableSetOf<StyleType>()
   val pendingStyleRemovals = mutableSetOf<StyleType>()
 
-  var isDuringTransaction = false
-    private set
-
-  var blockEmitting = false
+  val editSession = EditSession()
+  val blockCoordinator = BlockEditCoordinator(blockStore)
 
-  private var isTextChanging = false
-  var isProcessingTextChange = false
-    private set
-  private var didTextChangeRecently = false
   private var lastProcessedText: String = ""
   private var preEditSelectionStart = 0
   private var preEditSelectionEnd = 0
@@ -85,23 +97,109 @@ class EnrichedMarkdownTextInputView(
   val eventEmitter = InputEventEmitter(this)
   private val autoLinkDetector = AutoLinkDetector(formattingStore)
   private val detectorPipeline = DetectorPipeline()
+  private val mentionCoordinator = MentionCoordinator(formattingStore)
+  private val linkCoordinator = LinkCoordinator(formattingStore, autoLinkDetector)
 
-  val mathChipController: MathChipController? = MathChipController.resolve(context)
-  private var inputStyle: InputFormatterStyle? = null
-  private var activeMathChipPosition: Int = -1
-  private var pendingMathAtoms: List<com.swmansion.enriched.markdown.input.model.MathAtom> = emptyList()
-  private var lastReportedBlockWidth: Int = -1
+  private val editPipelineHost =
+    object : EditPipelineHost {
+      override val editable: Editable? get() = text
+      override val emitMarkdown: Boolean get() = this@EnrichedMarkdownTextInputView.emitMarkdown
+
+      override fun syncEmptyListAnchor(restamp: Boolean) = this@EnrichedMarkdownTextInputView.syncEmptyListAnchor(restamp)
+
+      override fun forceScrollToSelection() = this@EnrichedMarkdownTextInputView.forceScrollToSelection()
+
+      override fun syncCursorSizeWithBlock() = this@EnrichedMarkdownTextInputView.syncCursorSizeWithBlock()
+
+      override fun updateActiveMention() = this@EnrichedMarkdownTextInputView.dispatchMentionUpdate()
+
+      override fun runAsATransaction(block: () -> Unit) = this@EnrichedMarkdownTextInputView.runAsATransaction(block)
+
+      override fun setViewSelection(position: Int) = setSelection(position)
+    }
+
+  val editPipeline =
+    EditPipeline(
+      formattingStore = formattingStore,
+      blockStore = blockStore,
+      formatter = formatter,
+      detectorPipeline = detectorPipeline,
+      eventEmitter = eventEmitter,
+      host = editPipelineHost,
+    )
 
   private var textWatcher: MarkdownTextWatcher? = null
   private var inputMethodManager: InputMethodManager? = null
   private var detectScrollMovement = false
   var scrollEnabled: Boolean = true
 
-  private var mentionIndicators: LinkedHashSet<String> = linkedSetOf()
-  private var activeMentionIndicator: String? = null
-  private var activeMentionStart = -1
-  private var activeMentionEnd = -1
-  private var activeMentionText = ""
+  private val clipboardCoordinator = ClipboardCoordinator(formattingStore, blockStore, detectorPipeline, formatter)
+
+  // region Math chip state
+  //
+  // Null when the build has math disabled (the `src/math/java` source set is excluded,
+  // so `resolve()` finds no implementation). Every math path below returns early on
+  // null, which is what makes a math-disabled build a silent no-op instead of a crash.
+  val mathChipController: MathChipController? = MathChipController.resolve(context)
+
+  // The chip spans hold a resolved style object, so the view has to keep the last
+  // `markdownStyle` around to re-stamp them; InputFormatter keeps its copy private.
+  private var inputStyle: InputFormatterStyle? = null
+
+  // Chip whose selected styling is currently drawn, or -1. Kept so the caret leaving
+  // the chip can clear it — a span cannot observe selection changes itself.
+  private var activeMathChipPosition = -1
+
+  // Atoms parsed before `markdownStyle` arrived. @ReactProp setters fire in undefined
+  // order, so `defaultValue` can land first; they are drained by the style setter.
+  private var pendingMathAtoms: List<MathAtom> = emptyList()
+
+  private var lastReportedBlockWidth = -1
+  // endregion
+
+  private var headingOverrideBaseSizePx: Float? = null
+  private var baseHintColor: Int? = null
+
+  // Number of ZWSP empty-list anchors believed live in the buffer. Bumped on insert,
+  // made exact on every strip scan (which recounts what it keeps), and reset when the
+  // buffer is replaced. Incoming markdown is scrubbed of U+200B at parse time, so in
+  // practice only syncEmptyListAnchor's own inserts raise it. When it is 0 there is
+  // nothing to strip, letting syncEmptyListAnchor skip its O(document) backward scan
+  // on every caret move.
+  private var zwspAnchorCount = 0
+
+  // The consumer-set placeholder, hidden while a bullet is drawn on an empty editor.
+  private var userHint: CharSequence? = null
+
+  // When on, a paste is reported to JS instead of inserted. Native never touches
+  // the buffer here (see resolvePaste): if JS dies mid-handler the paste is a
+  // visible no-op rather than a selection that silently vanished.
+  //
+  // The listener is installed only while the prop is on. Registering it
+  // unconditionally would route every consumer's paste through AppCompat's
+  // receive-content path even with the feature off, which is a behavior change
+  // nobody asked for.
+  var interceptPaste: Boolean = false
+    set(value) {
+      if (field == value) return
+      field = value
+      ViewCompat.setOnReceiveContentListener(
+        this,
+        if (value) PASTE_MIME_TYPES else null,
+        if (value) receiveContentListener else null,
+      )
+    }
+
+  // The markdown last handed over by JS, kept so `blockSyntax` can re-parse it. @ReactProp
+  // setters fire in undefined order, so `defaultValue` regularly lands before the flag does.
+  private var lastMarkdownFromJS: String? = null
+
+  var blockSyntax: Boolean = true
+    set(value) {
+      if (field == value) return
+      field = value
+      lastMarkdownFromJS?.let { setValueFromJS(it) }
+    }
 
   init {
     setupDetectorPipeline()
@@ -110,16 +208,6 @@ class EnrichedMarkdownTextInputView(
     isComponentReady = true
   }
 
-  /**
-   * Width a full-bleed block math chip can claim. Read late (every layout pass),
-   * because TextView's width is established after measure. Falls back to 0 when
-   * we haven't been measured yet — span will then use its intrinsic width.
-   */
-  private fun availableBlockWidth(): Int {
-    val w = width - totalPaddingLeft - totalPaddingRight
-    return w.coerceAtLeast(0)
-  }
-
   private fun setupDetectorPipeline() {
     autoLinkDetector.onLinkDetected = { text, url, start, end ->
       eventEmitter.emitLinkDetected(text, url, start, end)
@@ -164,6 +252,13 @@ class EnrichedMarkdownTextInputView(
     runAsATransaction { super.setTextIsSelectable(true) }
   }
 
+  /**
+   * Width a full-bleed block math chip may claim. Read late (on every layout pass)
+   * because a TextView's width is only known after measure; 0 before the first
+   * measure, which makes the span fall back to its intrinsic width.
+   */
+  private fun availableBlockWidth(): Int = (width - totalPaddingLeft - totalPaddingRight).coerceAtLeast(0)
+
   override fun onSizeChanged(
     w: Int,
     h: Int,
@@ -175,9 +270,9 @@ class EnrichedMarkdownTextInputView(
     val available = availableBlockWidth()
     if (available == lastReportedBlockWidth) return
     lastReportedBlockWidth = available
-    // First measurement (oldw==0) is the moment block chips get a real width;
-    // we need to invalidate their cached layout so getSize returns the new
-    // full-bleed width. Same for rotation / resize.
+    // The first measure (oldw == 0) is where block chips first get a real width, so
+    // their cached layout has to be dropped for getSize to report the new full-bleed
+    // width. Rotation and resize land here too.
     refreshAllMathChips()
   }
 
@@ -198,16 +293,62 @@ class EnrichedMarkdownTextInputView(
     return InputConnectionWrapper(base, this)
   }
 
+  // Plain Tab is consumed before the platform's focus navigation so it inserts
+  // a tab character and emits onKeyPress, matching iOS. Shift/Ctrl+Tab still
+  // navigate focus.
   override fun onKeyDown(
     keyCode: Int,
     event: KeyEvent?,
   ): Boolean {
+    if (keyCode == KeyEvent.KEYCODE_TAB && event?.hasNoModifiers() != false) {
+      eventEmitter.emitKeyPress("Tab")
+      val start = minOf(selectionStart, selectionEnd).coerceAtLeast(0)
+      val end = maxOf(selectionStart, selectionEnd).coerceAtLeast(0)
+      text?.replace(start, end, "\t")
+      return true
+    }
     if (keyCode == KeyEvent.KEYCODE_DEL && deleteLinkBeforeCursor()) {
       return true
     }
+    if (handleListKey(keyCode, event)) {
+      return true
+    }
     return super.onKeyDown(keyCode, event)
   }
 
+  /**
+   * Hardware-keyboard list editing: Tab indents the current item, Shift+Tab outdents,
+   * and Backspace at the start of an item (or on an empty/ZWSP-anchored item) outdents,
+   * then un-lists at depth 0. Only fires on a list line; returns true when handled.
+   */
+  private fun handleListKey(
+    keyCode: Int,
+    event: KeyEvent?,
+  ): Boolean {
+    val listBlock = listBlockAtCursor() ?: return false
+    val depth = listBlock.level
+    when (keyCode) {
+      KeyEvent.KEYCODE_TAB -> {
+        if (event?.isShiftPressed == true) outdentList() else indentList()
+        return true
+      }
+
+      KeyEvent.KEYCODE_DEL -> {
+        if (selectionStart == selectionEnd) {
+          val editable = text ?: return false
+          val ls = blockCoordinator.lineStartOf(editable, selectionStart)
+          val le = blockCoordinator.lineEndOf(editable, selectionStart)
+          val content = editable.subSequence(ls, le).toString()
+          if (selectionStart == ls || content.isEmpty() || content == ZWSP.toString()) {
+            if (depth > 0) outdentList() else toggleListType(listBlock.type)
+            return true
+          }
+        }
+      }
+    }
+    return false
+  }
+
   // Prevents TextView from deferring its internal layout when a Fabric
   // state-update (height change) triggers requestLayout(). Without this
   // override the deferred relayout causes a visible flicker of styled spans.
@@ -234,8 +375,15 @@ class EnrichedMarkdownTextInputView(
 
       MotionEvent.ACTION_UP -> {
         val chipPosition = mathChipPositionAtTouch(ev.x, ev.y)
-        if (chipPosition >= 0 && handleMathChipTap(chipPosition)) {
-          return true
+        if (chipPosition >= 0) {
+          // super FIRST, then the chip handling on top of it. ACTION_UP is where View
+          // takes focus and where the editor shows the soft keyboard; consuming it
+          // outright would make the first tap on a chip in an unfocused editor open
+          // nothing — the Android twin of the iOS tap-to-focus stall fixed in 475ecdab.
+          // handleMathChipTap re-seats the caret afterwards, overriding the hit-test
+          // position super just set.
+          val handledBySuper = super.onTouchEvent(ev)
+          return handleMathChipTap(chipPosition) || handledBySuper
         }
       }
     }
@@ -250,6 +398,10 @@ class EnrichedMarkdownTextInputView(
     x: Int,
     y: Int,
   ) {
+    if (text.isNullOrEmpty()) {
+      super.scrollTo(x, 0)
+      return
+    }
     if (!scrollEnabled) return
     super.scrollTo(x, y)
   }
@@ -267,17 +419,16 @@ class EnrichedMarkdownTextInputView(
   }
 
   fun runAsATransaction(block: () -> Unit) {
-    try {
-      isDuringTransaction = true
+    if (editSession.phase != EditPhase.Idle) {
       block()
-    } finally {
-      isDuringTransaction = false
+    } else {
+      editSession.scoped(EditPhase.Processing) { block() }
     }
   }
 
   fun onBeforeTextChanged() {
-    if (isProcessingTextChange) return
-    isTextChanging = true
+    if (editSession.phase != EditPhase.Idle) return
+    editSession.isTextChanging = true
     preEditSelectionStart = selectionStart
     preEditSelectionEnd = selectionEnd
   }
@@ -287,32 +438,30 @@ class EnrichedMarkdownTextInputView(
     deletedLength: Int,
     insertedLength: Int,
   ) {
-    if (isProcessingTextChange) return
+    if (editSession.phase != EditPhase.Idle) return
 
     val currentText = text?.toString() ?: ""
     if (currentText == lastProcessedText) return
 
-    isProcessingTextChange = true
+    editSession.enter(EditPhase.Processing)
     try {
-      formattingStore.adjustForEdit(editStart, deletedLength, insertedLength)
-      applyPendingStyles(editStart, insertedLength)
-      applyFormatting()
-
-      val editable = text
-      if (editable != null) {
-        detectorPipeline.processTextChange(editable, currentText, editStart, insertedLength)
-      }
-
-      forceScrollToSelection()
-      eventEmitter.emitChangeText()
-      if (emitMarkdown) eventEmitter.emitChangeMarkdown()
-      updateActiveMention()
-      eventEmitter.emitCaretRectChangeIfNeeded()
-      isTextChanging = false
-      didTextChangeRecently = true
-      lastProcessedText = currentText
+      val context =
+        EditContext(
+          editStart = editStart,
+          deletedLength = deletedLength,
+          insertedLength = insertedLength,
+          preEditText = currentText,
+          preEditSelectionStart = preEditSelectionStart,
+          preEditSelectionEnd = preEditSelectionEnd,
+          pendingStyles = pendingStyles.toSet(),
+          pendingStyleRemovals = pendingStyleRemovals.toSet(),
+        )
+      editPipeline.processTextChange(context)
+      editSession.isTextChanging = false
+      editSession.didTextChangeRecently = true
+      lastProcessedText = text?.toString() ?: currentText
     } finally {
-      isProcessingTextChange = false
+      editSession.exit()
     }
   }
 
@@ -321,70 +470,107 @@ class EnrichedMarkdownTextInputView(
     selEnd: Int,
   ) {
     super.onSelectionChanged(selStart, selEnd)
-    if (!isComponentReady || isDuringTransaction) return
+    if (!isComponentReady || editSession.shouldSuppressTextWatcher) return
 
-    if (!isTextChanging) {
-      // Links (e.g. mentions) are atomic: snap a partial selection to the whole link, and a caret
-      // inside a link to its end. Returning lets the recursive onSelectionChanged emit for the result.
+    if (!editSession.isTextChanging) {
       formattingStore.selectionAdjustedForAtomicLinks(selStart, selEnd)?.let { (newStart, newEnd) ->
         setSelection(newStart, newEnd)
         return
       }
-      if (didTextChangeRecently) {
-        didTextChangeRecently = false
+      if (editSession.didTextChangeRecently) {
+        editSession.didTextChangeRecently = false
       } else {
         pendingStyles.clear()
         pendingStyleRemovals.clear()
+        seedPendingStylesFromSelection(selStart, selEnd)
       }
     }
 
-    val isCaretOnChip =
+    if (!editSession.isTextChanging && editSession.phase == EditPhase.Idle) {
+      // The caret moving on/off an empty bullet line toggles the ZWSP anchor and the
+      // placeholder visibility; skip during a text-change pass (handled there).
+      syncEmptyListAnchor()
+    }
+
+    // A chip stays highlighted only while the caret sits on either of its two edges;
+    // any other caret move (or a real selection) drops the highlight.
+    val isCaretOnActiveChip =
       selStart == selEnd &&
         activeMathChipPosition >= 0 &&
         (selStart == activeMathChipPosition || selStart == activeMathChipPosition + 1)
-    if (!isCaretOnChip) {
+    if (!isCaretOnActiveChip) {
       clearMathChipSelections()
       activeMathChipPosition = -1
     }
 
     eventEmitter.emitSelection(selStart, selEnd)
-    updateActiveMention()
+    dispatchMentionUpdate()
     eventEmitter.emitState()
     eventEmitter.emitCaretRectChangeIfNeeded()
   }
 
-  private fun applyPendingStyles(
-    editStart: Int,
-    insertedLength: Int,
+  /**
+   * Text typed over a non-empty selection inherits the inline styles of the first
+   * selected character (mirrors iOS rebuildFromContext and the range-inheritance
+   * rule in [com.swmansion.enriched.markdown.input.formatting.RangeEditAdjustment]).
+   * Seeding here is the only chance to carry the style through the whole typed
+   * run: the post-edit grace period above skips reseeding between keystrokes.
+   * LINK is excluded — typing over a selected link replaces it, not extends it.
+   */
+  private fun seedPendingStylesFromSelection(
+    selStart: Int,
+    selEnd: Int,
   ) {
-    if (insertedLength == 0) return
-    if (pendingStyles.isEmpty() && pendingStyleRemovals.isEmpty()) return
-
-    val rangeStart = if (preEditSelectionStart != preEditSelectionEnd) preEditSelectionStart else editStart
-    val rangeEnd = rangeStart + insertedLength
-
-    // Skip applying pending styles when the insertion is only line breaks —
-    // a phantom range over a bare newline corrupts isStyleActive() at the boundary.
-    val currentText = text
-    val insertedHasGlyphContent =
-      currentText != null &&
-        rangeEnd <= currentText.length &&
-        (rangeStart until rangeEnd).any { !currentText[it].isLineBreak() }
-
-    if (insertedHasGlyphContent) {
-      for (style in pendingStyles) {
-        formattingStore.addRange(FormattingRange(style, rangeStart, rangeEnd))
+    if (selStart == selEnd) return
+    for (style in StyleType.entries) {
+      if (style == StyleType.LINK) continue
+      if (formattingStore.isStyleActive(style, selStart)) {
+        pendingStyles.add(style)
       }
     }
+  }
 
-    for (style in pendingStyleRemovals) {
-      formattingStore.removeType(style, rangeStart, rangeEnd)
+  /**
+   * Adjusts both [formattingStore] and [blockStore] for a text edit, then prunes
+   * orphaned anchors and normalizes block ranges to line bounds. Every code path
+   * that mutates the text buffer must call this so block ranges stay in sync —
+   * mirrors iOS's `replaceTextInRange:withText:formattingRanges:blockRanges:`.
+   */
+  private fun adjustStoresForEdit(
+    editStart: Int,
+    deletedLength: Int,
+    insertedLength: Int,
+  ) {
+    formattingStore.adjustForEdit(editStart, deletedLength, insertedLength)
+    blockStore.adjustForEdit(editStart, deletedLength, insertedLength)
+    editPipeline.pruneOrphanedAnchors()
+    text?.let { blockStore.normalizeToLineBounds(it) }
+  }
+
+  private inline fun replaceTextInRange(
+    start: Int,
+    end: Int,
+    newText: String,
+    postAdjust: (Editable) -> Unit = {},
+  ) {
+    val editable = text ?: return
+    editSession.enter(EditPhase.Processing)
+    try {
+      editable.replace(start, end, newText)
+      adjustStoresForEdit(start, end - start, newText.length)
+      postAdjust(editable)
+      lastProcessedText = editable.toString()
+      applyFormattingAndEmit()
+      eventEmitter.emitChangeText()
+    } finally {
+      editSession.exit()
     }
   }
 
   fun applyFormatting() {
     val editable = text ?: return
     formatter.applyFormatting(editable, formattingStore.allRanges)
+    formatter.applyBlockFormatting(editable, blockStore.allRanges)
   }
 
   private fun applyFormattingAndEmit() {
@@ -395,6 +581,11 @@ class EnrichedMarkdownTextInputView(
   }
 
   private fun forceScrollToSelection() {
+    if (text.isNullOrEmpty()) {
+      super.scrollTo(scrollX, 0)
+      return
+    }
+
     val textLayout = layout ?: return
     val cursorOffset = selectionStart
     if (cursorOffset <= 0) return
@@ -423,21 +614,12 @@ class EnrichedMarkdownTextInputView(
   fun toggleInlineStyle(styleType: StyleType) {
     val handler = formatter.handlers[styleType] ?: return
     val mergingConfig = handler.mergingConfig
-
     val selStart = selectionStart
     val selEnd = selectionEnd
 
-    // Check blocking rules: if any blocking style is active, refuse to toggle on.
-    if (mergingConfig.blockingStyles.isNotEmpty()) {
-      val isCurrentlyActive = formattingStore.isStyleActive(styleType, selStart)
-      if (!isCurrentlyActive) {
-        for (blocker in mergingConfig.blockingStyles) {
-          if (formattingStore.isStyleActive(blocker, selStart)) {
-            return
-          }
-        }
-      }
-    }
+    if (formattingStore.isToggleBlocked(styleType, selStart, mergingConfig.blockingStyles)) return
+
+    val result = formattingStore.toggleStyle(styleType, selStart, selEnd, mergingConfig.conflictingStyles)
 
     if (selStart == selEnd) {
       if (pendingStyleRemovals.contains(styleType)) {
@@ -446,72 +628,419 @@ class EnrichedMarkdownTextInputView(
       } else if (pendingStyles.contains(styleType)) {
         pendingStyles.remove(styleType)
         pendingStyleRemovals.add(styleType)
-      } else if (formattingStore.isStyleActive(styleType, selStart)) {
+      } else if (result == FormattingStore.ToggleResult.WAS_ACTIVE) {
         pendingStyleRemovals.add(styleType)
       } else {
         pendingStyles.add(styleType)
       }
       eventEmitter.emitState()
     } else {
-      val isActive = formattingStore.isStyleActive(styleType, selStart)
-      if (isActive) {
-        formattingStore.removeType(styleType, selStart, selEnd)
-      } else {
-        // Remove conflicting styles from the range before applying.
-        for (conflict in mergingConfig.conflictingStyles) {
-          formattingStore.removeType(conflict, selStart, selEnd)
+      applyFormattingAndEmit()
+      pendingStyles.clear()
+      pendingStyleRemovals.clear()
+      seedPendingStylesFromSelection(selStart, selEnd)
+    }
+  }
+
+  private fun listBlockAtCursor(): BlockRange? {
+    val editable = text ?: return null
+    return blockCoordinator.listBlockAtPosition(editable, selectionStart)
+  }
+
+  fun listStateAtCursor(type: BlockType): Pair<Boolean, Int> {
+    val editable = text ?: return false to 0
+    return blockCoordinator.listStateAtPosition(editable, selectionStart, type)
+  }
+
+  fun toggleUnorderedList() = toggleListType(BlockType.UNORDERED_LIST_ITEM)
+
+  fun toggleOrderedList() = toggleListType(BlockType.ORDERED_LIST_ITEM)
+
+  private fun toggleListType(type: BlockType) {
+    val editable = text ?: return
+    blockCoordinator.toggleList(editable, type, selectionStart, selectionStart, selectionEnd)
+    applyFormattingAndEmit()
+    syncEmptyListAnchor()
+  }
+
+  /** Increases the nesting depth of the selected list item(s). QoL: indenting a plain paragraph starts a list. */
+  fun indentList() = changeListDepthBy(1)
+
+  /** Decreases the nesting depth; outdenting at depth 0 removes the list marker. */
+  fun outdentList() = changeListDepthBy(-1)
+
+  private fun changeListDepthBy(delta: Int) {
+    val editable = text ?: return
+    val result = blockCoordinator.changeDepth(editable, selectionStart, selectionStart, selectionEnd, delta)
+    if (result == BlockEditCoordinator.DepthChangeResult.NO_OP) return
+    applyFormattingAndEmit()
+    syncEmptyListAnchor()
+  }
+
+  /**
+   * Keeps an empty bullet line anchored by a ZWSP so its marker draws and the caret
+   * indents (a [android.text.style.LeadingMarginSpan] doesn't indent an empty
+   * paragraph). Inserts the ZWSP on the caret's empty list line, strips stale ones.
+   *
+   * @param restamp re-apply block formatting here (selection/command paths); the
+   *   text-change pass passes false and stamps once afterwards.
+   * @return true if an anchor was inserted or stripped (text/ranges mutated).
+   *
+   * When called from `onAfterTextChanged` this mutates the [Editable] from inside
+   * the text-change callback — normally an Android hazard around IME composition,
+   * undo/redo, and accessibility. It is safe here, and deliberately synchronous,
+   * because: every buffer mutation is wrapped in [runAsATransaction] (which keeps
+   * [EditSession.phase] non-idle, so [MarkdownTextWatcher] early-returns and the edit
+   * does not re-enter this pass), the whole `onAfterTextChanged` body holds
+   * [EditPhase.Processing], and [EditPhase.ManagingAnchors] blocks re-entry via the
+   * selection-change path. The mutation must stay synchronous: the single-stamp
+   * ordering above, the caret placement past the anchor, and `lastProcessedText`
+   * all depend on the buffer reaching its final state within this same callback —
+   * deferring the insert/delete (e.g. via `post`) would run it outside every guard
+   * and reintroduce the double-bullet and stale-caret bugs.
+   */
+  private fun syncEmptyListAnchor(restamp: Boolean = true): Boolean {
+    if (editSession.shouldSuppressAnchorSync) return false
+    val editable = text ?: return false
+    editSession.enter(EditPhase.ManagingAnchors)
+    var anchorChanged = false
+    try {
+      // Strip every stale ZWSP first (a line that gained content or stopped being a
+      // list). Skip the full-document scan when we've inserted no anchors — there is
+      // nothing to strip, so a caret move in a document with no empty list lines is
+      // O(1) instead of O(document length). When the scan does run it recounts the
+      // anchors it keeps, so the count is exact afterwards — a prior overcount (an
+      // anchor the user deleted directly) or an undercount (a foreign ZWSP that stole
+      // a decrement) self-heals rather than disabling the fast path or leaking a
+      // stale anchor.
+      if (zwspAnchorCount > 0) {
+        var keptAnchors = 0
+        var i = editable.length - 1
+        while (i >= 0) {
+          if (editable[i] == ZWSP) {
+            val ls = blockCoordinator.lineStartOf(editable, i)
+            val le = blockCoordinator.lineEndOf(editable, i)
+            val onlyZwsp = le - ls == 1 && editable[ls] == ZWSP
+            val isEmptyListLine = onlyZwsp && blockCoordinator.listBlockAtLineStart(ls) != null
+            if (!isEmptyListLine) {
+              runAsATransaction { editable.delete(i, i + 1) }
+              blockStore.adjustForEdit(i, 1, 0)
+              anchorChanged = true
+            } else {
+              keptAnchors++
+            }
+          }
+          i--
         }
-        formattingStore.addRange(FormattingRange(styleType, selStart, selEnd))
+        zwspAnchorCount = keptAnchors
       }
-      applyFormattingAndEmit()
+
+      val caret = selectionStart
+      if (selectionStart == selectionEnd) {
+        val ls = blockCoordinator.lineStartOf(editable, caret)
+        val le = blockCoordinator.lineEndOf(editable, caret)
+        val block = blockCoordinator.listBlockAtLineStart(ls)
+        if (block != null && le == ls) {
+          runAsATransaction { editable.insert(ls, ZWSP.toString()) }
+          blockStore.adjustForEdit(ls, 0, 1)
+          blockStore.normalizeToLineBounds(editable)
+          setSelection(ls + 1)
+          zwspAnchorCount++
+          anchorChanged = true
+        }
+      }
+
+      if (anchorChanged) {
+        // Re-snap any range left zero-length by a strip so the next stamp is exact.
+        blockStore.normalizeToLineBounds(editable)
+        if (restamp) applyFormatting()
+        lastProcessedText = editable.toString()
+        if (emitMarkdown) eventEmitter.emitChangeMarkdown()
+      }
+      syncHintVisibility()
+      return anchorChanged
+    } finally {
+      editSession.exit()
     }
   }
 
-  // Copies the input's plain text to the system clipboard without disturbing
-  // the current selection. Android's system clipboard round-trip is plain text
-  // only — inline styles are not preserved for external paste targets.
+  /**
+   * The hint shows only on a truly empty editor with no block range — a bullet's
+   * ZWSP anchor counts as content, so the hint never overlaps a marker. Mirrors iOS.
+   */
+  private fun syncHintVisibility() {
+    val content = text
+    val hasRealText = content != null && content.any { it != ZWSP }
+    val hasBlock = blockStore.allRanges.isNotEmpty()
+    val target: CharSequence? = if (hasRealText || hasBlock) "" else userHint
+    if (hint != target) super.setHint(target)
+  }
+
+  fun setUserHint(value: CharSequence?) {
+    userHint = value
+    syncHintVisibility()
+  }
+
+  // Copies the whole input as markdown without disturbing the current selection,
+  // tagged so paste restores formatting and block ranges — mirrors iOS, which
+  // stores markdown under its custom pasteboard type.
   fun copyToClipboard() {
     val content = text
     if (content.isNullOrEmpty()) return
     val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager ?: return
-    clipboard.setPrimaryClip(ClipData.newPlainText(null, content))
+    val markdown = clipboardCoordinator.serializeFullDocument(content.toString(), content, mathChipsForSerialization())
+    clipboard.setPrimaryClip(MarkdownClipboard.newMarkdownClip(markdown, content.toString()))
+  }
+
+  // Copy/cut re-tag the clip with markdown and paste restores it, so formatting
+  // and block ranges survive the round trip — mirrors iOS's copy:/cut:/paste:
+  // overrides. External clips keep default handling.
+  //
+  // Paste arrives by two different routes and only the first one is a menu.
+  // This override covers the context menu and the hardware Ctrl+V /
+  // KEYCODE_PASTE shortcuts; drag-and-drop, autofill and IME `commitContent`
+  // reach the view through `onReceiveContent` instead. Hooking only one of them
+  // leaves the other pasting straight into the buffer with nobody intercepting.
+  override fun onTextContextMenuItem(id: Int): Boolean {
+    // Checked before the markdown paste below, which would otherwise insert first.
+    if (interceptPaste && (id == android.R.id.paste || id == android.R.id.pasteAsPlainText)) {
+      val text = readClipboardText()
+      if (text.isNotEmpty()) {
+        eventEmitter.emitPaste(text, "")
+        // Returning without super keeps this single-emit: AppCompat would route
+        // its own paste through the receive-content listener below.
+        return true
+      }
+      // Nothing textual in the clip: fall through to the regular handling,
+      // matching what the listener does with the items it does not claim.
+    }
+    if (id == android.R.id.paste) {
+      MarkdownClipboard.markdownFromClipboard(context)?.let { markdown ->
+        pasteMarkdown(markdown)
+        return true
+      }
+      // External plain text is treated as markdown so pasted syntax ("- ", "#",
+      // "**") formats instead of landing literal; syntax-free text is unchanged.
+      // "Paste as plain text" (pasteAsPlainText) keeps the literal default.
+      plainTextFromClipboard()?.let { plainText ->
+        pasteMarkdown(plainText)
+        return true
+      }
+    }
+    if (id == android.R.id.copy || id == android.R.id.cut) {
+      val selStart = selectionStart
+      val selEnd = selectionEnd
+      val plainText = if (selStart < selEnd) text?.substring(selStart, selEnd) else null
+      val markdown = markdownForSelectedRange()
+      val handled = super.onTextContextMenuItem(id)
+      if (handled && markdown != null && plainText != null) {
+        val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager
+        clipboard?.setPrimaryClip(MarkdownClipboard.newMarkdownClip(markdown, plainText))
+      }
+      return handled
+    }
+    return super.onTextContextMenuItem(id)
+  }
+
+  fun markdownForSelectedRange(): String? {
+    val fullText = text?.toString() ?: return null
+    return clipboardCoordinator.serializeSelectedRange(
+      fullText,
+      selectionStart,
+      selectionEnd,
+      text,
+      mathChipsForSerialization(),
+    )
+  }
+
+  private fun plainTextFromClipboard(): String? {
+    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager ?: return null
+    val item = clipboard.primaryClip?.takeIf { it.itemCount > 0 }?.getItemAt(0) ?: return null
+    return item.coerceToText(context)?.toString()?.takeIf { it.isNotEmpty() }
+  }
+
+  /**
+   * Replaces the selection with parsed markdown, importing its inline formatting
+   * and block ranges (headings etc.) into the stores — mirrors iOS pasteMarkdown.
+   *
+   * Insertion is literal: the string's characters land at the cursor exactly as
+   * given. Markdown parsing consumes leading and trailing newlines as block
+   * structure, so they are split off before the parse and re-attached verbatim;
+   * without this, insertText("\n- item\n") mid-paragraph would merge the list
+   * line with the surrounding text. Callers decide separation by including (or
+   * omitting) newlines in the string.
+   */
+  fun pasteMarkdown(markdown: String) {
+    val editable = text ?: return
+    val prefix = markdown.takeWhile { it == '\n' }
+    val suffix = if (markdown.length > prefix.length) markdown.takeLastWhile { it == '\n' } else ""
+    val core = markdown.substring(prefix.length, markdown.length - suffix.length)
+    val parsed = InputParser.parseToPlainTextAndRanges(core, blockSyntax)
+    val selStart = selectionStart.coerceIn(0, editable.length)
+    val selEnd = selectionEnd.coerceIn(selStart, editable.length)
+
+    val plainText = prefix + parsed.plainText + suffix
+    val contentStart = selStart + prefix.length
+
+    replaceTextInRange(selStart, selEnd, plainText) { editable ->
+      for (range in parsed.formattingRanges) {
+        formattingStore.addRange(
+          FormattingRange(range.type, range.start + contentStart, range.end + contentStart, range.url),
+        )
+      }
+      for (block in parsed.blockRanges) {
+        blockStore.setBlock(block.type, block.level, block.start + contentStart, block.end + contentStart, editable)
+      }
+      applyMathAtoms(editable, parsed.mathAtoms, offset = contentStart)
+      setSelection(selStart + plainText.length)
+      detectorPipeline.processTextChange(editable, editable.toString(), selStart, plainText.length)
+    }
+  }
+
+  /** Toggles a heading (H1-H6) on the cursor's paragraph(s); the active level toggles back to a paragraph. */
+  fun toggleHeading(level: Int) {
+    val blockType = BlockType.forHeadingLevel(level) ?: return
+    toggleBlockType(blockType, level)
+  }
+
+  private fun toggleBlockType(
+    type: BlockType,
+    level: Int,
+  ) {
+    val editable = text ?: return
+    val selStart = selectionStart.coerceIn(0, editable.length)
+    val selEnd = selectionEnd.coerceIn(selStart, editable.length)
+    blockCoordinator.toggleBlock(editable, type, level, selStart, selEnd)
+    applyFormattingAndEmit()
+    syncCursorSizeWithBlock()
+  }
+
+  private fun blockOnParagraphAt(pos: Int): BlockRange? {
+    val editable = text ?: return null
+    return blockCoordinator.blockAtPosition(editable, pos)
+  }
+
+  private fun listBlockStartingAt(lineStart: Int): BlockRange? = blockCoordinator.listBlockAtLineStart(lineStart)
+
+  fun headingLevelAtCursor(): Int {
+    val editable = text ?: return 0
+    return blockCoordinator.headingLevelAtPosition(editable, selectionStart)
+  }
+
+  /**
+   * On empty text with a heading block, overrides text size to the heading's
+   * font size so the cursor matches heading height. Hides the hint while
+   * active. Cleared automatically when text is typed or heading is toggled off.
+   */
+  private fun syncCursorSizeWithBlock() {
+    val editable = text ?: return
+    val block = blockOnParagraphAt(selectionStart)
+
+    if (block != null && block.type in BlockType.HEADINGS && editable.isEmpty()) {
+      val headingSizePx = formatter.resolveHeadingFontSizePx(block.level) ?: return
+      if (headingOverrideBaseSizePx == null) {
+        headingOverrideBaseSizePx = paint.textSize
+        baseHintColor = currentHintTextColor
+        setHintTextColor(Color.TRANSPARENT)
+      }
+      if (paint.textSize != headingSizePx) {
+        setTextSize(TypedValue.COMPLEX_UNIT_PX, headingSizePx)
+      }
+    } else {
+      headingOverrideBaseSizePx?.let { baseSizePx ->
+        setTextSize(TypedValue.COMPLEX_UNIT_PX, baseSizePx)
+        headingOverrideBaseSizePx = null
+        baseHintColor?.let { setHintTextColor(it) }
+        baseHintColor = null
+      }
+    }
+  }
+
+  private val receiveContentListener =
+    OnReceiveContentListener { _, payload ->
+      // The listener also sees autofill, drag-and-drop, IME commitContent and
+      // PROCESS_TEXT. Without this filter an autofill would turn into a paste
+      // event — and a consumer would turn that into an attachment chip.
+      if (!interceptPaste || payload.source != ContentInfoCompat.SOURCE_CLIPBOARD) {
+        return@OnReceiveContentListener payload
+      }
+      val parts = payload.partition { it.text != null }
+      parts.first?.let { accepted ->
+        val clip = accepted.clip
+        val text = PasteTextUtils.joinClipTexts((0 until clip.itemCount).map { clip.getItemAt(it).text })
+        if (text.isNotEmpty()) {
+          eventEmitter.emitPaste(text, "")
+        }
+      }
+      // Hand back only what we did not claim, so the buffer stays untouched.
+      parts.second
+    }
+
+  private fun readClipboardText(): String {
+    val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager ?: return ""
+    val clip = clipboard.primaryClip ?: return ""
+    // `text`, not `coerceToText`: the listener can only claim items that already
+    // carry text, and the two routes have to agree on what counts as a paste.
+    return PasteTextUtils.joinClipTexts((0 until clip.itemCount).map { clip.getItemAt(it).text })
+  }
+
+  /**
+   * Completes a paste reported through `onPaste`. `pastedText` lands verbatim —
+   * not parsed as markdown, unlike the un-intercepted paste — and `markdown` is
+   * ignored. Android reports `markdown` as `''` (see `onTextContextMenuItem`),
+   * which is the contract 0.7.4 shipped with, although copy/cut here now tag the
+   * clip with markdown through [MarkdownClipboard].
+   *
+   * Goes through [replaceTextInRange] like [pasteMarkdown], so the formatting and
+   * block stores and the empty-list anchors are adjusted as for any other edit.
+   *
+   * Resolving with an empty string and an empty selection is a zero-length edit
+   * — it still emits, which keeps the JS contract identical on both platforms.
+   */
+  fun resolvePaste(
+    pastedText: String,
+    @Suppress("UNUSED_PARAMETER") markdown: String,
+  ) {
+    val editable = text ?: return
+    val selStart = selectionStart.coerceIn(0, editable.length)
+    val selEnd = selectionEnd.coerceIn(selStart, editable.length)
+
+    replaceTextInRange(selStart, selEnd, pastedText) { ed ->
+      setSelection(selStart + pastedText.length)
+      // Parity with the un-intercepted paste: a pasted URL still autolinks.
+      detectorPipeline.processTextChange(ed, ed.toString(), selStart, pastedText.length)
+    }
+    // The session suppresses onSelectionChanged while the edit runs, so the moved
+    // caret is reported here.
+    eventEmitter.emitSelection(selectionStart, selectionEnd)
+    eventEmitter.emitCaretRectChangeIfNeeded()
   }
 
   fun setLinkForSelection(url: String) {
     val selStart = selectionStart
     val selEnd = selectionEnd
     if (selStart == selEnd) return
-
-    val editable = text
-    if (editable != null) {
-      autoLinkDetector.clearAutoLinkInRange(editable, selStart, selEnd)
-    }
-    formattingStore.addRange(FormattingRange(StyleType.LINK, selStart, selEnd, url))
+    linkCoordinator.setLinkForRange(url, selStart, selEnd, text)
     applyFormattingAndEmit()
   }
 
+  /** Parses the given markdown and inserts it at the cursor, replacing any selection. */
+  fun insertTextAtCursor(markdown: String) {
+    if (markdown.isEmpty()) return
+    pasteMarkdown(markdown)
+  }
+
   fun insertLinkAtCursor(
     displayText: String,
     url: String,
   ) {
-    val editable = text ?: return
     val selStart = selectionStart
     val selEnd = selectionEnd
     val linkEnd = selStart + displayText.length
 
-    isProcessingTextChange = true
-    try {
-      editable.replace(selStart, selEnd, displayText)
-      formattingStore.adjustForEdit(selStart, selEnd - selStart, displayText.length)
-      autoLinkDetector.clearAutoLinkInRange(editable, selStart, linkEnd)
-      formattingStore.addRange(FormattingRange(StyleType.LINK, selStart, linkEnd, sanitizeLinkUrl(url)))
-      lastProcessedText = editable.toString()
-
+    replaceTextInRange(selStart, selEnd, displayText) { editable ->
+      linkCoordinator.addLink(url, selStart, linkEnd, editable)
       setSelection(linkEnd)
-      applyFormattingAndEmit()
-      eventEmitter.emitChangeText()
-    } finally {
-      isProcessingTextChange = false
     }
   }
 
@@ -520,206 +1049,116 @@ class EnrichedMarkdownTextInputView(
     url: String,
   ) {
     if (displayText.isEmpty()) return
-    val indicator = activeMentionIndicator ?: return
-    val start = activeMentionStart
-    val end = activeMentionEnd
+    val indicator = mentionCoordinator.currentIndicator ?: return
+    val start = mentionCoordinator.currentStart
+    val end = mentionCoordinator.currentEnd
     val editable = text ?: return
     if (start < 0 || end < start || end > editable.length) return
 
-    val sanitizedUrl = sanitizeLinkUrl(url)
     val shouldAppendSpace = end >= editable.length || !editable[end].isWhitespace()
     val replacement = if (shouldAppendSpace) "$displayText " else displayText
     val linkEnd = start + displayText.length
 
-    isProcessingTextChange = true
-    try {
-      editable.replace(start, end, replacement)
-      formattingStore.adjustForEdit(start, end - start, replacement.length)
-      autoLinkDetector.clearAutoLinkInRange(editable, start, linkEnd)
-      formattingStore.addRange(FormattingRange(StyleType.LINK, start, linkEnd, sanitizedUrl))
-      lastProcessedText = editable.toString()
-
-      clearActiveMention(emit = true, indicatorOverride = indicator)
+    replaceTextInRange(start, end, replacement) { ed ->
+      linkCoordinator.addLink(url, start, linkEnd, ed)
+      dispatchMentionEvents(mentionCoordinator.clear(indicatorOverride = indicator))
       setSelection(start + replacement.length)
-      applyFormattingAndEmit()
-      eventEmitter.emitChangeText()
-    } finally {
-      isProcessingTextChange = false
     }
   }
 
   fun startMention(indicator: String) {
-    if (indicator.isEmpty() || indicator !in mentionIndicators) return
-    val editable = text ?: return
+    if (indicator.isEmpty() || !mentionCoordinator.containsIndicator(indicator)) return
     val selStart = selectionStart
     val selEnd = selectionEnd
 
-    isProcessingTextChange = true
-    try {
-      editable.replace(selStart, selEnd, indicator)
-      formattingStore.adjustForEdit(selStart, selEnd - selStart, indicator.length)
-      lastProcessedText = editable.toString()
+    replaceTextInRange(selStart, selEnd, indicator) {
       setSelection(selStart + indicator.length)
-      applyFormattingAndEmit()
-      eventEmitter.emitChangeText()
-      updateActiveMention()
-    } finally {
-      isProcessingTextChange = false
     }
+    dispatchMentionUpdate()
   }
 
   fun removeLinkAtCursor() {
-    val pos = selectionStart
-    val linkRange = formattingStore.rangeOfType(StyleType.LINK, pos) ?: return
-    formattingStore.removeRange(linkRange)
+    if (!linkCoordinator.removeLink(selectionStart)) return
     applyFormattingAndEmit()
   }
 
-  fun deleteLinkBeforeCursor(): Boolean {
-    val editable = text ?: return false
-    val cursorStart = selectionStart
-    val cursorEnd = selectionEnd
-    if (cursorStart != cursorEnd || cursorStart <= 0) return false
-
-    val linkRange = formattingStore.rangeOfType(StyleType.LINK, cursorStart - 1) ?: return false
-
-    isProcessingTextChange = true
-    try {
-      editable.delete(linkRange.start, linkRange.end)
-      formattingStore.adjustForEdit(linkRange.start, linkRange.length, 0)
-      lastProcessedText = editable.toString()
-      setSelection(linkRange.start.coerceAtMost(editable.length))
-      applyFormattingAndEmit()
-      eventEmitter.emitChangeText()
-      clearActiveMention()
-    } finally {
-      isProcessingTextChange = false
-    }
-    return true
-  }
-
-  fun setMentionIndicators(indicators: List<String>) {
-    val newIndicators = LinkedHashSet(indicators)
-    if (newIndicators == mentionIndicators) return
-    mentionIndicators = newIndicators
-    activeMentionIndicator?.let { indicator ->
-      if (indicator !in mentionIndicators) {
-        clearActiveMention(emit = true, indicatorOverride = indicator)
-      }
-    }
-    updateActiveMention()
-  }
-
-  fun dismissActiveMention() {
-    clearActiveMention(emit = false)
-  }
-
-  fun setContextMenuItems(items: List<String>) {
-    contextMenu.setContextMenuItems(items)
-  }
-
-  fun setLinkRegex(config: LinkRegexConfig) {
-    autoLinkDetector.setRegexConfig(config)
-  }
-
-  fun setAutoLinkStyle(style: InputFormatterStyle) {
-    autoLinkDetector.style = style
-  }
-
-  fun allFormattingRangesForSerialization(): List<FormattingRange> {
-    val editable = text ?: return formattingStore.allRanges
-    val transientRanges = detectorPipeline.allTransientFormattingRanges(editable)
-    if (transientRanges.isEmpty()) return formattingStore.allRanges
-    return formattingStore.allRanges + transientRanges
-  }
-
-  fun setValueFromJS(markdown: String) {
-    val parsed = InputParser.parseToPlainTextAndRanges(markdown)
-    blockEmitting = true
-    try {
-      runAsATransaction {
-        formattingStore.clearAll()
-        formattingStore.setRanges(parsed.formattingRanges)
-        setText(parsed.plainText)
-        val editable = text
-        if (editable != null && parsed.mathAtoms.isNotEmpty()) {
-          applyMathAtoms(editable, parsed.mathAtoms)
-        }
-        setSelection(text?.length ?: 0)
-      }
-      applyFormatting()
-      forceScrollToSelection()
-      layoutManager.invalidateLayout()
-      lastProcessedText = text?.toString() ?: ""
-    } finally {
-      blockEmitting = false
-    }
+  // region Math chip
+  //
+  // A chip is one OBJECT_REPLACEMENT character in the buffer plus a MathChipSpan that
+  // carries the LaTeX and draws the rendered formula. Nothing about the formula lives
+  // in the text, so the caret, the IME and every range in the stores treat it as a
+  // single atomic character. All text mutation goes through the same
+  // replaceTextInRange/EditPhase machinery as links and mentions — the pre-merge fork
+  // hand-rolled its own re-entrancy flags, which no longer exist.
+
+  /** Chips in document order, as plain data for [MarkdownSerializer]. Empty with math off. */
+  fun mathChipsForSerialization(): List<MathChipController.ChipInfo> {
+    val controller = mathChipController ?: return emptyList()
+    val editable = text ?: return emptyList()
+    return controller.allChips(editable)
   }
 
+  /**
+   * Stamps parsed [atoms] onto placeholder characters already present in [editable],
+   * shifting their positions by [offset] (non-zero when the parse covered an inserted
+   * fragment rather than the whole buffer).
+   */
   private fun applyMathAtoms(
     editable: Editable,
-    atoms: List<com.swmansion.enriched.markdown.input.model.MathAtom>,
+    atoms: List<MathAtom>,
+    offset: Int = 0,
   ) {
     val controller = mathChipController ?: return
+    // Clear first: a math-free import still has to disarm atoms deferred by an earlier
+    // buffer, or they would be stamped onto whatever text replaced them.
+    pendingMathAtoms = emptyList()
+    if (atoms.isEmpty()) return
+    val positioned = if (offset == 0) atoms else atoms.map { it.copy(position = it.position + offset) }
     val style = inputStyle
     if (style == null) {
-      // `markdownStyle` hasn't arrived yet — defer until applyInputStyle runs.
-      // @ReactProp setters fire in undefined order, so defaultValue may run first.
-      pendingMathAtoms = atoms
+      // `markdownStyle` has not arrived yet. @ReactProp setters fire in undefined order,
+      // so `defaultValue` can be applied first — the only producer that reaches this
+      // branch, which is why a plain assignment (not an append) is correct here.
+      pendingMathAtoms = positioned
       return
     }
-    pendingMathAtoms = emptyList()
-    isProcessingTextChange = true
-    try {
-      controller.applyAtoms(editable, atoms, style.math, style.mathBlock)
-    } finally {
-      isProcessingTextChange = false
+    controller.applyAtoms(editable, positioned, style.inlineMath, style.math)
+  }
+
+  /**
+   * Pushes a new `markdownStyle` into every live chip, and drains any atoms that were
+   * parsed before the style existed. Both cases move the measured text height, which
+   * Fabric owns — [InputLayoutManager.invalidateLayout] is the only way to change it.
+   */
+  private fun syncMathChipsWithStyle(style: InputFormatterStyle) {
+    val controller = mathChipController ?: return
+    val editable = text ?: return
+    val pending = pendingMathAtoms
+    if (pending.isNotEmpty()) {
+      pendingMathAtoms = emptyList()
+      controller.applyAtoms(editable, pending, style.inlineMath, style.math)
+    } else {
+      // Chips cache the style object they were built with, so a style pass has to
+      // re-stamp them; with no chip in the buffer there is nothing to do and no
+      // reason to make Fabric re-measure.
+      if (controller.allChips(editable).isEmpty()) return
+      controller.refreshAll(editable, style.inlineMath, style.math)
     }
+    invalidate()
+    requestLayout()
+    layoutManager.invalidateLayout()
   }
 
+  /** Re-stamps every chip with the current style — used when the row width changes. */
   fun refreshAllMathChips() {
     val controller = mathChipController ?: return
     val editable = text ?: return
     val style = inputStyle ?: return
-    controller.refreshAll(editable, style.math, style.mathBlock)
+    if (controller.allChips(editable).isEmpty()) return
+    controller.refreshAll(editable, style.inlineMath, style.math)
     invalidate()
     requestLayout()
-  }
-
-  fun applyInputStyle(style: InputFormatterStyle): Boolean {
-    val previous = inputStyle
-    inputStyle = style
-    val changed = previous != style
-    val mathStyleChanged =
-      previous == null ||
-        previous.math != style.math ||
-        previous.mathBlock != style.mathBlock
-
-    val controller = mathChipController
-    val editable = text
-    if (controller != null && editable != null && pendingMathAtoms.isNotEmpty()) {
-      val atoms = pendingMathAtoms
-      pendingMathAtoms = emptyList()
-      isProcessingTextChange = true
-      try {
-        controller.applyAtoms(editable, atoms, style.math, style.mathBlock)
-      } finally {
-        isProcessingTextChange = false
-      }
-      invalidate()
-      requestLayout()
-      // Chips only reach the text here when `defaultValue` landed before `markdownStyle`
-      // (@ReactProp order is undefined). requestLayout() cannot change a height Fabric owns —
-      // the shadow tree has to re-measure text that now carries the spans.
-      layoutManager.invalidateLayout()
-    } else if (mathStyleChanged) {
-      refreshAllMathChips()
-      // A math font size / padding change resizes every chip, so the measured height moves.
-      // Colour-only changes end up here too; store() then measures the same size and skips
-      // the state update.
-      layoutManager.invalidateLayout()
-    }
-    return changed
+    layoutManager.invalidateLayout()
   }
 
   fun insertMath(
@@ -731,42 +1170,32 @@ class EnrichedMarkdownTextInputView(
     val style = inputStyle ?: return
     val editable = text ?: return
 
-    val selStart = selectionStart.coerceAtLeast(0)
-    val selEnd = selectionEnd.coerceAtLeast(selStart)
-    val safeStart = selStart.coerceAtMost(editable.length)
-    val safeEnd = selEnd.coerceAtMost(editable.length)
-
-    val prefix = StringBuilder()
-    val suffix = StringBuilder()
-    if (displayMode) {
-      val atLineStart = safeStart == 0 || editable[safeStart - 1] == '\n'
-      val atLineEnd = safeEnd >= editable.length || editable[safeEnd] == '\n'
-      if (!atLineStart) prefix.append('\n')
-      if (!atLineEnd) suffix.append('\n')
+    val selStart = selectionStart.coerceIn(0, editable.length)
+    val selEnd = selectionEnd.coerceIn(selStart, editable.length)
+
+    // A block chip claims the full row, so it needs a line of its own: add the
+    // separators the caret position is missing rather than pulling the surrounding
+    // text into the chip's line.
+    val prefix = if (displayMode && selStart > 0 && !editable[selStart - 1].isLineBreak()) "\n" else ""
+    val suffix = if (displayMode && selEnd < editable.length && !editable[selEnd].isLineBreak()) "\n" else ""
+    val replacement = prefix + OBJECT_REPLACEMENT + suffix
+    val chipPosition = selStart + prefix.length
+    // style.inlineMath is `markdownStyle.inlineMath`, style.math is the block key —
+    // they swapped names in the P7 rename and both are chip styles, so a stale read
+    // compiles clean and styles the wrong chip.
+    val chipStyle: MathChipStyle = if (displayMode) style.math else style.inlineMath
+
+    replaceTextInRange(selStart, selEnd, replacement) { updated ->
+      controller.insertChip(updated, chipPosition, latex, displayMode, chipStyle)
+      setSelection((selStart + replacement.length).coerceAtMost(updated.length))
     }
-    val replacement = "$prefix$suffix"
-    val chipPositionInReplacement = prefix.length
 
-    isProcessingTextChange = true
-    try {
-      editable.replace(safeStart, safeEnd, replacement)
-      val chipPosition = safeStart + chipPositionInReplacement
-      val chipStyle: MathChipStyle = if (displayMode) style.mathBlock else style.math
-      controller.insertChip(editable, chipPosition, latex, displayMode, chipStyle)
-      formattingStore.adjustForEdit(safeStart, safeEnd - safeStart, replacement.length)
-      lastProcessedText = editable.toString()
-      setSelection(safeStart + replacement.length)
-    } finally {
-      isProcessingTextChange = false
-    }
-
-    applyFormatting()
     invalidate()
     requestLayout()
-    eventEmitter.emitChangeText()
-    if (emitMarkdown) eventEmitter.emitChangeMarkdown()
+    layoutManager.invalidateLayout()
+    // replaceTextInRange emits text/markdown/state; the selection it set was applied
+    // inside the Processing phase, where onSelectionChanged bails out.
     eventEmitter.emitSelection(selectionStart, selectionEnd)
-    eventEmitter.emitState()
     eventEmitter.emitCaretRectChangeIfNeeded()
   }
 
@@ -778,11 +1207,13 @@ class EnrichedMarkdownTextInputView(
     val controller = mathChipController ?: return
     val style = inputStyle ?: return
     val editable = text ?: return
-    val chipStyle: MathChipStyle = if (displayMode) style.mathBlock else style.math
-    val result = controller.updateChip(editable, start, latex, displayMode, chipStyle)
-    if (!result.applied) return
+    val chipStyle: MathChipStyle = if (displayMode) style.math else style.inlineMath
+    // Formula and mode live on the span, so this changes no text: no store adjustment
+    // and no EditPhase are needed, only a re-render and a re-measure.
+    if (!controller.updateChip(editable, start, latex, displayMode, chipStyle).applied) return
     invalidate()
     requestLayout()
+    layoutManager.invalidateLayout()
     if (emitMarkdown) eventEmitter.emitChangeMarkdown()
   }
 
@@ -790,22 +1221,32 @@ class EnrichedMarkdownTextInputView(
     val controller = mathChipController ?: return
     val editable = text ?: return
 
-    isProcessingTextChange = true
-    val didRemove =
-      try {
-        controller.removeChip(editable, start)
-      } finally {
-        isProcessingTextChange = false
+    // The controller does the delete because it also drops the chip's AlignmentSpan,
+    // which is SPAN_PARAGRAPH and would otherwise outlive the character and leave the
+    // rest of the paragraph centered.
+    var removed = false
+    editSession.enter(EditPhase.Processing)
+    try {
+      removed = controller.removeChip(editable, start)
+      if (removed) {
+        adjustStoresForEdit(start, 1, 0)
+        lastProcessedText = editable.toString()
+        applyFormattingAndEmit()
+        eventEmitter.emitChangeText()
       }
-    if (!didRemove) return
-    formattingStore.adjustForEdit(start, 1, 0)
-    lastProcessedText = editable.toString()
-    applyFormatting()
-    eventEmitter.emitChangeText()
-    if (emitMarkdown) eventEmitter.emitChangeMarkdown()
+    } finally {
+      editSession.exit()
+    }
+    if (!removed) return
+    if (activeMathChipPosition == start) activeMathChipPosition = -1
+    invalidate()
+    requestLayout()
+    layoutManager.invalidateLayout()
     eventEmitter.emitSelection(selectionStart, selectionEnd)
+    eventEmitter.emitCaretRectChangeIfNeeded()
   }
 
+  /** Drops the selected styling from every chip except [except] (all of them when -1). */
   private fun clearMathChipSelections(except: Int = -1) {
     val controller = mathChipController ?: return
     val editable = text ?: return
@@ -815,10 +1256,8 @@ class EnrichedMarkdownTextInputView(
       } else {
         var didChange = false
         for (chip in controller.allChips(editable)) {
-          if (chip.position == except) continue
-          if (chip.isSelected) {
-            if (controller.setSelected(editable, chip.position, false)) didChange = true
-          }
+          if (chip.position == except || !chip.isSelected) continue
+          if (controller.setSelected(editable, chip.position, false)) didChange = true
         }
         didChange
       }
@@ -829,19 +1268,20 @@ class EnrichedMarkdownTextInputView(
     val controller = mathChipController ?: return false
     val editable = text ?: return false
     val info = controller.chipAt(editable, chipPosition) ?: return false
-    val layoutNow = layout ?: return false
+    val textLayout = layout ?: return false
 
     clearMathChipSelections(except = info.position)
     controller.setSelected(editable, info.position, true)
     invalidate()
+    // Set before setSelection: onSelectionChanged reads it to decide whether the
+    // caret is still on the chip, and would otherwise clear the highlight at once.
     activeMathChipPosition = info.position
-    // Caret-after-chip (length 0). A length-1 selection would make the system
-    // draw selection handles over the chip glyph, and also trip the
-    // `selStart == selEnd` guard in onSelectionChanged that keeps the chip's
-    // selected style alive.
+    // Caret after the chip, not a length-1 selection: a selection would draw the
+    // system's selection handles over the chip glyph and trip the `selStart == selEnd`
+    // guard that keeps the chip's selected styling alive.
     setSelection((info.position + 1).coerceAtMost(editable.length))
 
-    val bounds = computeChipBounds(layoutNow, info.position)
+    val bounds = computeChipBounds(textLayout, info.position)
     val density = resources.displayMetrics.density.toDouble()
     eventEmitter.emitMathPress(
       info.latex,
@@ -858,57 +1298,58 @@ class EnrichedMarkdownTextInputView(
 
   /** Chip glyph rect in [Layout] coordinates — no padding, no scroll offset. */
   private fun chipBoundsInLayout(
-    layout: Layout,
+    textLayout: Layout,
     start: Int,
   ): Rect {
-    val line = layout.getLineForOffset(start)
-    val xStart = layout.getPrimaryHorizontal(start).toInt()
-    val xEnd = layout.getPrimaryHorizontal(start + 1).toInt()
-    // Ordered, not raw start/end: in an RTL run xStart > xEnd, which would make an
-    // inverted Rect that contains() always rejects.
+    val line = textLayout.getLineForOffset(start)
+    val xStart = textLayout.getPrimaryHorizontal(start).toInt()
+    val xEnd = textLayout.getPrimaryHorizontal(start + 1).toInt()
+    // Ordered, not raw start/end: in an RTL run xStart > xEnd, which would build an
+    // inverted Rect whose contains() always rejects.
     val left = xStart.coerceAtMost(xEnd)
     var right = xStart.coerceAtLeast(xEnd)
     if (right <= left) {
       // A chip that is the last character has start + 1 == length, where some layouts
-      // report the same horizontal for both offsets. Fall back to the line's content edge
-      // so the rect keeps a real width instead of collapsing.
-      right = layout.getLineRight(line).toInt()
+      // report the same horizontal for both offsets. Fall back to the line's content
+      // edge so the rect keeps a real width instead of collapsing.
+      right = textLayout.getLineRight(line).toInt()
     }
-    return Rect(left, layout.getLineTop(line), right, layout.getLineBottom(line))
+    return Rect(left, textLayout.getLineTop(line), right, textLayout.getLineBottom(line))
   }
 
   /** Chip glyph rect in view coordinates, for reporting to JS. */
   private fun computeChipBounds(
-    layout: Layout,
+    textLayout: Layout,
     start: Int,
   ): Rect =
-    chipBoundsInLayout(layout, start).apply {
+    chipBoundsInLayout(textLayout, start).apply {
       offset(totalPaddingLeft - scrollX, totalPaddingTop - scrollY)
     }
 
+  /** Offset of the chip under a touch point, or -1 when the touch missed every chip. */
   fun mathChipPositionAtTouch(
     x: Float,
     y: Float,
   ): Int {
     val controller = mathChipController ?: return -1
     val editable = text ?: return -1
-    val layoutNow = layout ?: return -1
+    val textLayout = layout ?: return -1
     val adjustedX = (x - totalPaddingLeft + scrollX).toInt()
     val adjustedY = (y - totalPaddingTop + scrollY).toInt()
-    // getLineForVertical and getOffsetForHorizontal both clamp into the laid-out text, so
-    // a touch in the padding or in the blank space below the last line resolves onto the
-    // nearest character. Bound the touch to the text box, then require it to land inside
-    // the chip's own rect — otherwise a tap beside a chip reads as a tap on it.
-    if (adjustedY < 0 || adjustedY > layoutNow.height) return -1
-    val line = layoutNow.getLineForVertical(adjustedY)
-    val offset = layoutNow.getOffsetForHorizontal(line, adjustedX.toFloat())
+    // getLineForVertical and getOffsetForHorizontal both clamp into the laid-out text,
+    // so a touch in the padding or in the blank space below the last line resolves onto
+    // the nearest character. Bound the touch to the text box first, then require it to
+    // land inside the chip's own rect — otherwise a tap beside a chip reads as a tap on it.
+    if (adjustedY < 0 || adjustedY > textLayout.height) return -1
+    val line = textLayout.getLineForVertical(adjustedY)
+    val offset = textLayout.getOffsetForHorizontal(line, adjustedX.toFloat())
     if (offset < 0) return -1
     val candidates = intArrayOf(offset, offset - 1).filter { it in 0 until editable.length }
     for (candidate in candidates) {
       val range = controller.chipRangeAt(editable, candidate) ?: continue
       // An empty rect means the layout could not give us the chip's extent; accept the
       // candidate then, rather than making the chip untappable.
-      val bounds = chipBoundsInLayout(layoutNow, range.first)
+      val bounds = chipBoundsInLayout(textLayout, range.first)
       if (!bounds.isEmpty && !bounds.contains(adjustedX, adjustedY)) continue
       return range.first
     }
@@ -916,13 +1357,13 @@ class EnrichedMarkdownTextInputView(
   }
 
   /**
-   * Shrink the IME composing region so it never overlaps a math chip. Returns
-   * the adjusted (start, end) pair, or null if no chip lies in the range. The
-   * caller should fall back to the original range when null is returned.
+   * Shrinks the IME composing region so it never overlaps a math chip, called from
+   * [com.swmansion.enriched.markdown.input.editing.InputConnectionWrapper.setComposingRegion].
+   * Returns the adjusted (start, end) pair, or null when there is no chip controller —
+   * the caller then keeps the original range.
    *
-   * If the region intersects a chip we collapse to the side furthest from the
-   * chip so a Korean/Japanese composing block can't accidentally swallow the
-   * chip's `` placeholder character.
+   * Where the region intersects a chip it collapses to the side furthest from the chip,
+   * so a Hangul/Kana composing block cannot swallow the chip's placeholder character.
    */
   fun adjustComposingRegionAwayFromChips(
     start: Int,
@@ -942,7 +1383,7 @@ class EnrichedMarkdownTextInputView(
         i++
         continue
       }
-      // Composing region overlaps a chip — push the edge that's nearest to the chip out.
+      // The region overlaps a chip — push out the edge nearest to it.
       val distFromStart = range.first - adjustedStart
       val distFromEnd = adjustedEnd - (range.last + 1)
       if (distFromStart >= distFromEnd) {
@@ -956,6 +1397,80 @@ class EnrichedMarkdownTextInputView(
     if (adjustedStart >= adjustedEnd) return adjustedStart to adjustedStart
     return adjustedStart to adjustedEnd
   }
+  // endregion
+
+  fun deleteLinkBeforeCursor(): Boolean {
+    val cursorStart = selectionStart
+    val cursorEnd = selectionEnd
+    if (cursorStart != cursorEnd || cursorStart <= 0) return false
+    if (text == null) return false
+
+    val linkRange = linkCoordinator.linkRangeForDeletion(cursorStart) ?: return false
+
+    replaceTextInRange(linkRange.start, linkRange.end, "") { editable ->
+      setSelection(linkRange.start.coerceAtMost(editable.length))
+    }
+    dispatchMentionEvents(mentionCoordinator.clear())
+    return true
+  }
+
+  fun setMentionIndicators(indicators: List<String>) {
+    dispatchMentionEvents(mentionCoordinator.setIndicators(indicators))
+    dispatchMentionUpdate()
+  }
+
+  fun dismissActiveMention() {
+    mentionCoordinator.clear(emit = false)
+  }
+
+  fun setContextMenuItems(items: List<String>) {
+    contextMenu.setContextMenuItems(items)
+  }
+
+  fun setLinkRegex(config: LinkRegexConfig) {
+    autoLinkDetector.setRegexConfig(config)
+  }
+
+  fun setAutoLinkStyle(style: InputFormatterStyle) {
+    autoLinkDetector.style = style
+  }
+
+  /**
+   * Applies the parsed `markdownStyle` (which now carries `list.itemSpacing`).
+   * Display density is folded in at [InputFormatter] construction, so the style is
+   * handed to the formatter as-is. Returns true if the effective style changed
+   * (caller re-applies formatting).
+   */
+  fun setMarkdownStyleFromProps(style: InputFormatterStyle): Boolean {
+    setAutoLinkStyle(style)
+    inputStyle = style
+    val changed = formatter.updateStyle(style)
+    syncMathChipsWithStyle(style)
+    return changed
+  }
+
+  fun allFormattingRangesForSerialization(): List<FormattingRange> = clipboardCoordinator.allRangesForSerialization(text)
+
+  fun setValueFromJS(markdown: String) {
+    lastMarkdownFromJS = markdown
+    val parsed = InputParser.parseToPlainTextAndRanges(markdown, blockSyntax)
+    editSession.enter(EditPhase.Importing)
+    try {
+      formattingStore.clearAll()
+      formattingStore.setRanges(parsed.formattingRanges)
+      blockStore.setRanges(parsed.blockRanges)
+      setText(parsed.plainText)
+      text?.let { applyMathAtoms(it, parsed.mathAtoms) }
+      setSelection(text?.length ?: 0)
+      zwspAnchorCount = 0
+      applyFormatting()
+      forceScrollToSelection()
+      layoutManager.invalidateLayout()
+      lastProcessedText = text?.toString() ?: ""
+    } finally {
+      editSession.exit()
+    }
+  }
 
   override fun setBackgroundColor(color: Int) {
     BackgroundStyleApplicator.setBackgroundColor(this, color)
@@ -1055,15 +1570,7 @@ class EnrichedMarkdownTextInputView(
   ) {
     if (start >= end) return
     val handler = formatter.handlers[styleType] ?: return
-    val isActive = formattingStore.isStyleActive(styleType, start)
-    if (isActive) {
-      formattingStore.removeType(styleType, start, end)
-    } else {
-      for (conflict in handler.mergingConfig.conflictingStyles) {
-        formattingStore.removeType(conflict, start, end)
-      }
-      formattingStore.addRange(FormattingRange(styleType, start, end))
-    }
+    formattingStore.toggleStyle(styleType, start, end, handler.mergingConfig.conflictingStyles)
     applyFormattingAndEmit()
   }
 
@@ -1072,81 +1579,25 @@ class EnrichedMarkdownTextInputView(
     start: Int,
     end: Int,
   ) {
-    if (start >= end) return
-    formattingStore.addRange(FormattingRange(StyleType.LINK, start, end, url))
+    linkCoordinator.addLinkDirect(url, start, end)
     applyFormattingAndEmit()
   }
 
-  private fun updateActiveMention() {
-    val plainText = text?.toString() ?: return
-    val cursor = selectionStart
-    if (selectionStart != selectionEnd || cursor < 0 || cursor > plainText.length) {
-      clearActiveMention()
-      return
-    }
-
-    val candidate = detectMentionAtCursor(plainText, cursor)
-    if (candidate == null) {
-      clearActiveMention()
-      return
-    }
-
-    if (activeMentionIndicator != candidate.indicator || activeMentionStart != candidate.start) {
-      activeMentionIndicator?.let { eventEmitter.emitEndMention(it) }
-      activeMentionIndicator = candidate.indicator
-      activeMentionStart = candidate.start
-      eventEmitter.emitStartMention(candidate.indicator)
-    }
-
-    activeMentionEnd = candidate.end
-    if (activeMentionText != candidate.text) {
-      activeMentionText = candidate.text
-      eventEmitter.emitChangeMention(candidate.indicator, candidate.text)
-    }
-  }
-
-  private fun detectMentionAtCursor(
-    plainText: String,
-    cursor: Int,
-  ): MentionCandidate? {
-    if (mentionIndicators.isEmpty()) return null
-
-    val start = WordsUtils.tokenStart(plainText, cursor)
-    val token = plainText.substring(start, cursor)
-    val indicator = mentionIndicators.firstOrNull { token.startsWith(it) } ?: return null
-    if (formattingStore.rangeOfType(StyleType.LINK, start) != null) return null
-
-    return MentionCandidate(
-      indicator = indicator,
-      start = start,
-      end = cursor,
-      text = token.substring(indicator.length),
-    )
+  private fun dispatchMentionUpdate() {
+    dispatchMentionEvents(mentionCoordinator.update(text?.toString(), selectionStart, selectionEnd))
   }
 
-  private fun clearActiveMention(
-    emit: Boolean = true,
-    indicatorOverride: String? = null,
-  ) {
-    val indicator = indicatorOverride ?: activeMentionIndicator
-    activeMentionIndicator = null
-    activeMentionStart = -1
-    activeMentionEnd = -1
-    activeMentionText = ""
-    if (emit && indicator != null) {
-      eventEmitter.emitEndMention(indicator)
+  private fun dispatchMentionEvents(events: List<MentionEvent>) {
+    for (event in events) {
+      when (event) {
+        is MentionEvent.Start -> eventEmitter.emitStartMention(event.indicator)
+        is MentionEvent.Change -> eventEmitter.emitChangeMention(event.indicator, event.text)
+        is MentionEvent.End -> eventEmitter.emitEndMention(event.indicator)
+      }
     }
   }
 
-  private fun sanitizeLinkUrl(url: String): String =
-    url
-      .replace("(", "%28")
-      .replace(")", "%29")
-
-  private data class MentionCandidate(
-    val indicator: String,
-    val start: Int,
-    val end: Int,
-    val text: String,
-  )
+  private companion object {
+    private val PASTE_MIME_TYPES = arrayOf("text/*")
+  }
 }