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

package/ios/input/EnrichedMarkdownTextInput.mm

@@ -1,26 +1,30 @@
 #import "EnrichedMarkdownTextInput.h"
 #import "ContextMenuUtils.h"
 #import "ENRMAutoLinkDetector.h"
+#import "ENRMBlockEditCoordinator.h"
+#import "ENRMBlockHandler.h"
+#import "ENRMBlockStore.h"
+#import "ENRMClipboardCoordinator.h"
 #import "ENRMDetectorPipeline.h"
-#import "ENRMFeatureFlags.h"
+#import "ENRMEditPipeline.h"
+#import "ENRMEditSession.h"
 #import "ENRMFormattingRange.h"
 #import "ENRMFormattingStore.h"
+#import "ENRMInputEventEmitter.h"
 #import "ENRMInputFormatter.h"
 #import "ENRMInputLayoutManager.h"
 #import "ENRMInputLinkPrompt.h"
-#import "ENRMInputMentionCandidate.h"
+#import "ENRMInputListMarkerDrawer.h"
 #import "ENRMInputParser.h"
 #import "ENRMInputTextView.h"
+#import "ENRMInputTypingAttributesController.h"
+#import "ENRMLinkCoordinator.h"
 #import "ENRMLinkRegexConfig.h"
-#import "ENRMMarkdownSerializer.h"
-#import "ENRMMathFontWeight.h"
-#if ENRICHED_MARKDOWN_MATH
-#import "ENRMMathInlineAttachment.h"
-#endif
+#import "ENRMMathChipController.h"
+#import "ENRMMentionCoordinator.h"
 #import "ENRMStyleHandler.h"
 #import "ENRMStyleMergingConfig.h"
 #import "ENRMUIKit.h"
-#import "ENRMWordsUtils.h"
 #import "EnrichedMarkdownTextInput+Internal.h"
 #import "InputStylePropsUtils.h"
 #import "ParagraphStyleUtils.h"
@@ -45,17 +49,25 @@
 using namespace facebook::react;
 
 #if !TARGET_OS_OSX
+// UIGestureRecognizerDelegate is for the math chip tap: it has to run alongside
+// UITextView's own selection gestures, never instead of them.
 @interface EnrichedMarkdownTextInput () <RCTEnrichedMarkdownTextInputViewProtocol, UITextViewDelegate,
-                                         UIGestureRecognizerDelegate>
+                                         ENRMEditPipelineHost, ENRMInputEventEmitterDataSource,
+                                         ENRMInputTypingAttributesDataSource, UIGestureRecognizerDelegate>
 #else
-@interface EnrichedMarkdownTextInput () <RCTEnrichedMarkdownTextInputViewProtocol, RCTBackedTextInputDelegate>
+@interface EnrichedMarkdownTextInput () <RCTEnrichedMarkdownTextInputViewProtocol, RCTBackedTextInputDelegate,
+                                         ENRMEditPipelineHost, ENRMInputEventEmitterDataSource,
+                                         ENRMInputTypingAttributesDataSource>
 #endif
 - (void)setupTextView;
 - (void)applyFormatting;
+- (void)applyFormattingScopedToEditAtLocation:(NSUInteger)editLocation insertedLength:(NSUInteger)insertedLength;
 - (void)toggleInlineStyle:(ENRMInputStyleType)styleType;
 - (void)resetBaseTypingAttributes;
 @end
 
+static const NSTimeInterval kENRMAtomicSnapPollInterval = 0.1;
+
 @implementation EnrichedMarkdownTextInput {
   ENRMPlatformTextView *_textView;
   ENRMInputLayoutManager *_layoutManager;
@@ -64,24 +76,30 @@ using namespace facebook::react;
   ENRMInputFormatter *_formatter;
   ENRMInputFormatterStyle *_formatterStyle;
   ENRMFormattingStore *_formattingStore;
-  NSMutableSet<NSNumber *> *_pendingStyles;
-  NSMutableSet<NSNumber *> *_pendingStyleRemovals;
-  BOOL _isApplyingFormatting;
-  BOOL _isTextChanging;
-  BOOL _emitMarkdown;
-  CFTimeInterval _lastTextChangeTime;
+  ENRMBlockStore *_blockStore;
+  ENRMInputTypingAttributesController *_typingController;
+  ENRMInputEventEmitter *_inputEventEmitter;
+  ENRMEditSession *_editSession;
+  BOOL _blockSyntax;
+  NSString *_lastImportedMarkdown;
 
   ENRMPlaceholderLabel *_placeholderLabel;
 
   NSUInteger _lastTextLength;
   NSRange _lastSelectedRange;
   NSRange _preEditSelectedRange;
-
-  struct {
-    BOOL bold, italic, underline, strikethrough, spoiler, link, initialized;
-  } _prevState;
-
-  std::optional<CGRect> _prevCaretRect;
+  BOOL _atomicSnapScheduled;
+
+  // Block type/level of the line being edited, captured before a text change so
+  // a Return that continues a list (or an autocorrect/paste that replaces the
+  // line) can restore the right block on the resulting line(s).
+  ENRMInputBlockType _preEditBlockType;
+  NSInteger _preEditBlockLevel;
+  BOOL _preEditParagraphWasEmpty;
+  // Whether the replaced range contained a line break, captured before the edit
+  // applies (the deleted characters are gone afterwards). Drives the full-vs-
+  // scoped reformat decision in handleTextChanged.
+  BOOL _preEditReplacedNewline;
 
 #if TARGET_OS_OSX
   NSScrollView *_scrollView;
@@ -89,25 +107,24 @@ using namespace facebook::react;
 
   NSArray<NSString *> *_contextMenuItemTexts;
   NSArray<NSString *> *_contextMenuItemIcons;
-  NSArray<NSString *> *_mentionIndicators;
-  NSString *_activeMentionIndicator;
-  NSRange _activeMentionRange;
-  NSString *_activeMentionText;
-
   ENRMAutoLinkDetector *_autoLinkDetector;
   ENRMDetectorPipeline *_detectorPipeline;
+  ENRMEditPipeline *_editPipeline;
+  ENRMBlockEditCoordinator *_blockCoordinator;
+  ENRMMentionCoordinator *_mentionCoordinator;
+  ENRMLinkCoordinator *_linkCoordinator;
+  ENRMClipboardCoordinator *_clipboardCoordinator;
+  ENRMMathChipController *_mathChipController;
+
+  // Buffer position of the math chip currently drawn selected, or NSNotFound.
+  NSUInteger _activeMathChipPosition;
+  // A caret move made by the chip tap itself must not clear the highlight the tap
+  // just set; consumed by the next selection change.
+  BOOL _suppressMathChipClearOnce;
 
   ENRMWritingDirectionMode _writingDirectionMode;
   NSWritingDirection _resolvedLayoutDirection;
 
-  /// One-shot guard: when YES, the next textViewDidChangeSelection skips
-  /// clearing math chip selections. Set by handleTapForMathChip right before
-  /// it moves the caret to the chip, so the caret update doesn't immediately
-  /// wipe the chip we just selected.
-  BOOL _suppressMathChipClearOnce;
-  /// Character index of the currently selected math chip, or NSNotFound.
-  NSUInteger _activeMathChipIndex;
-
   ENRMInputSelectionMenuConfig _inputSelectionMenuConfig;
   ENRMFormatMenuConfig _formatMenuConfig;
 
@@ -123,6 +140,8 @@ using namespace facebook::react;
   NSString *_formatMenuLinkLabel;
 }
 
+@synthesize editSession = _editSession;
+
 #pragma mark - Fabric lifecycle
 
 + (ComponentDescriptorProvider)componentDescriptorProvider
@@ -142,18 +161,16 @@ using namespace facebook::react;
     _props = defaultProps;
 
     self.backgroundColor = [RCTUIColor clearColor];
-    _blockEmitting = NO;
+    _blockSyntax = YES;
+    _lastImportedMarkdown = nil;
     _heightUpdateCounter = 0;
     _formatter = [[ENRMInputFormatter alloc] init];
     _formatterStyle = [[ENRMInputFormatterStyle alloc] init];
     _formattingStore = [[ENRMFormattingStore alloc] init];
-    _pendingStyles = [NSMutableSet set];
-    _pendingStyleRemovals = [NSMutableSet set];
+    _blockStore = [[ENRMBlockStore alloc] init];
     _lastTextLength = 0;
     _lastSelectedRange = NSMakeRange(0, 0);
-    _mentionIndicators = @[];
-    _activeMentionRange = NSMakeRange(NSNotFound, 0);
-    _activeMentionText = @"";
+    _mentionCoordinator = [[ENRMMentionCoordinator alloc] initWithFormattingStore:_formattingStore];
 
     _writingDirectionMode = ENRMWritingDirectionModeFirstStrong;
     _resolvedLayoutDirection =
@@ -162,12 +179,32 @@ using namespace facebook::react;
     _formatMenuConfig = (ENRMFormatMenuConfig){
         .bold = YES, .italic = YES, .underline = YES, .strikethrough = YES, .spoiler = YES, .link = YES};
 
+    _activeMathChipPosition = NSNotFound;
     _suppressMathChipClearOnce = NO;
-    _activeMathChipIndex = NSNotFound;
 
     [self setupTextView];
+    _mathChipController = [[ENRMMathChipController alloc] initWithTextView:_textView style:_formatterStyle];
+    _editSession = [[ENRMEditSession alloc] initWithTextView:_textView];
+    _typingController = [[ENRMInputTypingAttributesController alloc] initWithTextView:_textView
+                                                                       formatterStyle:_formatterStyle
+                                                                           dataSource:self
+                                                                          editSession:_editSession];
+    _inputEventEmitter = [[ENRMInputEventEmitter alloc] initWithDataSource:self];
 
     [self setupDetectorPipeline];
+
+    _editPipeline = [[ENRMEditPipeline alloc] initWithFormattingStore:_formattingStore
+                                                           blockStore:_blockStore
+                                                            formatter:_formatter
+                                                     detectorPipeline:_detectorPipeline
+                                                                 host:self];
+    _blockCoordinator = [[ENRMBlockEditCoordinator alloc] initWithBlockStore:_blockStore];
+    _linkCoordinator = [[ENRMLinkCoordinator alloc] initWithFormattingStore:_formattingStore
+                                                           autoLinkDetector:_autoLinkDetector];
+    _clipboardCoordinator = [[ENRMClipboardCoordinator alloc] initWithFormattingStore:_formattingStore
+                                                                           blockStore:_blockStore
+                                                               transientRangeProvider:_detectorPipeline
+                                                                            formatter:_formatter];
   }
   return self;
 }
@@ -180,7 +217,11 @@ using namespace facebook::react;
 
   __weak EnrichedMarkdownTextInput *weakSelf = self;
   _autoLinkDetector.onLinkDetected = ^(NSString *text, NSString *url, NSRange range) {
-    [weakSelf emitOnLinkDetectedWithText:text url:url range:range];
+    EnrichedMarkdownTextInput *strongSelf = weakSelf;
+    if (strongSelf == nil) {
+      return;
+    }
+    [strongSelf->_inputEventEmitter emitOnLinkDetectedWithText:text url:url range:range];
   };
 
   _detectorPipeline = [[ENRMDetectorPipeline alloc] init];
@@ -201,6 +242,8 @@ using namespace facebook::react;
   ENRMInputTextView *inputTextView = [[ENRMInputTextView alloc] initWithFrame:CGRectZero textContainer:textContainer];
 #else
   ENRMInputTextView *inputTextView = [[ENRMInputTextView alloc] initWithFrame:CGRectZero];
+  _layoutManager = [[ENRMInputLayoutManager alloc] init];
+  [inputTextView.textContainer replaceLayoutManager:_layoutManager];
 #endif
   inputTextView.markdownTextInput = self;
   _textView = inputTextView;
@@ -237,124 +280,89 @@ using namespace facebook::react;
   _placeholderLabel = ENRMCreatePlaceholderLabel(_textView, _formatterStyle.baseFont);
 #if !TARGET_OS_OSX
   _placeholderLabel.adjustsFontForContentSizeCategory = YES;
+  _placeholderLabel.accessibilityElementsHidden = YES;
+  _placeholderLabel.isAccessibilityElement = NO;
 #endif
 
   [self resetBaseTypingAttributes];
 
-#if ENRICHED_MARKDOWN_MATH && !TARGET_OS_OSX
-  UITapGestureRecognizer *mathTap = [[UITapGestureRecognizer alloc] initWithTarget:self
-                                                                            action:@selector(handleTapForMathChip:)];
-  mathTap.cancelsTouchesInView = NO;
-  mathTap.delaysTouchesBegan = NO;
-  mathTap.delaysTouchesEnded = NO;
-  mathTap.delegate = self;
-  [_textView addGestureRecognizer:mathTap];
+#if !TARGET_OS_OSX
+  if (ENRMMathChipController.isAvailable) {
+    UITapGestureRecognizer *mathTap = [[UITapGestureRecognizer alloc] initWithTarget:self
+                                                                              action:@selector(handleMathChipTap:)];
+    // The text view's own tap gestures must still run: swallowing the touch is
+    // what made the first tap on a chip fail to focus the field and raise the
+    // keyboard. This recognizer only adds behaviour, it never replaces any.
+    mathTap.cancelsTouchesInView = NO;
+    mathTap.delaysTouchesBegan = NO;
+    mathTap.delaysTouchesEnded = NO;
+    mathTap.delegate = self;
+    [_textView addGestureRecognizer:mathTap];
+  }
 #endif
 }
 
-#if ENRICHED_MARKDOWN_MATH && !TARGET_OS_OSX
-
-// Glyph rect of the chip at `index`, in _textView coordinates (the same space
-// `locationInView:_textView` reports). Single source of truth for both the tap
-// hit-test and the rect reported to JS.
-- (CGRect)mathChipRectInTextViewAtIndex:(NSUInteger)index layoutManager:(NSLayoutManager *)lm
+#if !TARGET_OS_OSX
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+    shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
 {
-  if (lm == nil)
-    return CGRectNull;
-  NSRange glyphRange = [lm glyphRangeForCharacterRange:NSMakeRange(index, 1) actualCharacterRange:NULL];
-  CGRect rect = [lm boundingRectForGlyphRange:glyphRange inTextContainer:_textView.textContainer];
-  rect.origin.x += _textView.textContainerInset.left;
-  rect.origin.y += _textView.textContainerInset.top;
-  return rect;
+  return YES;
 }
+#endif
+
+#if !TARGET_OS_OSX
+#pragma mark - Accessibility
 
-- (void)handleTapForMathChip:(UITapGestureRecognizer *)gesture
+// The custom TextKit 1 stack leaves the inner UITextView invisible to VoiceOver, so
+// the host vends the content itself as one readable element.
+- (BOOL)isAccessibilityElement
 {
-  if (gesture.state != UIGestureRecognizerStateRecognized)
-    return;
-  CGPoint loc = [gesture locationInView:_textView];
-  UITextPosition *pos = [_textView closestPositionToPoint:loc];
-  if (!pos)
-    return;
-  NSInteger idx = [_textView offsetFromPosition:_textView.beginningOfDocument toPosition:pos];
-  if (idx < 0)
-    return;
-  NSTextStorage *storage = _textView.textStorage;
-  NSLayoutManager *lm = storage.layoutManagers.firstObject;
-  // The closest position can land just past the chip, so probe both `idx` and `idx-1`.
-  // `closestPositionToPoint:` has no distance bound — it clamps a tap anywhere in the
-  // text view (blank space past the text, textContainerInset padding) onto the nearest
-  // character. Requiring the touch to fall inside the chip's own glyph rect is what
-  // keeps a tap beside a chip from reading as a tap on it.
-  ENRMMathInlineAttachment *att = nil;
-  NSUInteger chipIdx = NSNotFound;
-  for (NSInteger probe = idx; probe >= idx - 1; probe--) {
-    if (probe < 0 || (NSUInteger)probe >= storage.length)
-      continue;
-    id v = [storage attribute:NSAttachmentAttributeName atIndex:(NSUInteger)probe effectiveRange:NULL];
-    if (![v isKindOfClass:[ENRMMathInlineAttachment class]])
-      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.
-    CGRect rect = [self mathChipRectInTextViewAtIndex:(NSUInteger)probe layoutManager:lm];
-    if (!CGRectIsEmpty(rect) && !CGRectContainsPoint(rect, loc))
-      continue;
-    att = v;
-    chipIdx = (NSUInteger)probe;
-    break;
-  }
-  if (!att)
-    return;
+  return YES;
+}
 
-  NSRange chipRange = NSMakeRange(chipIdx, 1);
-  [self clearMathChipSelectionsExcept:chipRange];
-  att.isSelected = YES;
-  [att invalidateRender];
-  if (lm) {
-    [lm invalidateLayoutForCharacterRange:chipRange actualCharacterRange:NULL];
-    [lm ensureLayoutForCharacterRange:chipRange];
+- (NSString *)accessibilityValue
+{
+  NSString *text = ENRMGetPlainText(_textView);
+  if (text.length > 0) {
+    return text;
   }
-  ENRMSetNeedsDisplay(_textView);
-  // Place caret right after the chip (length 0) instead of selecting the chip
-  // — a length-1 selection would make UITextView draw its blue range handles
-  // on top of our custom selected-chip background.
-  NSUInteger caretIndex = chipIdx + 1;
-  if (caretIndex > storage.length)
-    caretIndex = storage.length;
-  _activeMathChipIndex = chipIdx;
-  _suppressMathChipClearOnce = YES;
-  _textView.selectedRange = NSMakeRange(caretIndex, 0);
+  if (_placeholderLabel.text.length > 0) {
+    return _placeholderLabel.text;
+  }
+  return [super accessibilityValue];
+}
+
+- (BOOL)accessibilityActivate
+{
+  ENRMFocusTextView(_textView);
+  [super accessibilityActivate];
+  return YES;
+}
+#endif
 
-  // Recomputed rather than reused from the hit-test: the layout was invalidated above.
-  CGRect glyphRect = [self mathChipRectInTextViewAtIndex:chipIdx layoutManager:lm];
-  CGRect rectInSelf = [self.contentView convertRect:glyphRect fromView:_textView];
+#pragma mark - Paste
 
-  [self emitOnMathPressWithLatex:att.latex start:chipIdx end:chipIdx + 1 displayMode:att.displayMode rect:rectInSelf];
+- (void)emitOnPasteWithText:(NSString *)text markdown:(NSString *)markdown
+{
+  [_inputEventEmitter emitOnPasteWithText:text markdown:markdown];
 }
 
-- (void)emitOnMathPressWithLatex:(NSString *)latex
-                           start:(NSUInteger)start
-                             end:(NSUInteger)end
-                     displayMode:(BOOL)displayMode
-                            rect:(CGRect)rect
+/// The single exit for an intercepted paste. One command rather than two makes
+/// "never swallow a paste" structural: the branch that turns the clipboard into
+/// something else still has to come through here, with empty strings.
+- (void)resolvePaste:(NSString *)text markdown:(NSString *)markdown
 {
-  auto emitter = [self getEventEmitter];
-  if (emitter == nullptr)
+  // Round-trips the formatting when the copy came from an input of ours;
+  // without this a copy-then-paste inside the app would land as flat text.
+  if (markdown.length > 0) {
+    [self pasteMarkdown:markdown];
     return;
-  emitter->onMathPress({
-      .latex = std::string([latex UTF8String] ?: ""),
-      .start = static_cast<int>(start),
-      .end = static_cast<int>(end),
-      .displayMode = displayMode ? true : false,
-      .x = rect.origin.x,
-      .y = rect.origin.y,
-      .width = rect.size.width,
-      .height = rect.size.height,
-  });
+  }
+  // Empty text with an empty selection is a zero-length edit: it still emits
+  // onChangeText with unchanged content, which the caller reads as a no-op.
+  [self replaceSelectedTextWith:text formattingRanges:@[]];
 }
 
-#endif
-
 #pragma mark - State
 
 - (void)updateState:(const facebook::react::State::Shared &)state
@@ -452,6 +460,10 @@ using namespace facebook::react;
     }
   }
 
+  if (newViewProps.interceptPaste != oldViewProps.interceptPaste) {
+    _interceptPaste = newViewProps.interceptPaste;
+  }
+
   if (newViewProps.multiline != oldViewProps.multiline) {
     _textView.textContainer.maximumNumberOfLines = newViewProps.multiline ? 0 : 1;
     _textView.textContainer.lineBreakMode =
@@ -479,7 +491,7 @@ using namespace facebook::react;
     ENRMApplySelectionColor(_textView, newViewProps.selectionColor);
   }
 
-  _emitMarkdown = newViewProps.isOnChangeMarkdownSet;
+  _inputEventEmitter.emitMarkdown = newViewProps.isOnChangeMarkdownSet;
 
   {
     auto configFromProp = [](const auto &prop) {
@@ -547,11 +559,8 @@ using namespace facebook::react;
         [indicators addObject:value];
       }
     }
-    _mentionIndicators = [indicators copy];
-    if (_activeMentionIndicator != nil && ![_mentionIndicators containsObject:_activeMentionIndicator]) {
-      [self clearActiveMention:_activeMentionIndicator];
-    }
-    [self updateActiveMention];
+    [self dispatchMentionEvents:[_mentionCoordinator setIndicators:indicators]];
+    [self dispatchMentionUpdate];
   }
 
   BOOL styleChanged = applyInputStyleProps(_formatterStyle, newViewProps, oldViewProps);
@@ -563,11 +572,20 @@ using namespace facebook::react;
     writingDirectionChanged = YES;
   }
 
+  // Must land before the defaultValue import below, so the first parse already sees
+  // the right flag. Assigned unconditionally, not just on change: the generated C++
+  // default is `false` while the JS default is `true`, so `blockSyntax={false}` on the
+  // first render compares equal to the old props and a change-guard would drop it.
+  BOOL blockSyntaxChanged = (_blockSyntax != (BOOL)newViewProps.blockSyntax);
+  _blockSyntax = newViewProps.blockSyntax;
+
   if (newViewProps.defaultValue != oldViewProps.defaultValue) {
     if (!newViewProps.defaultValue.empty() && oldViewProps.defaultValue.empty()) {
       NSString *markdown = [NSString stringWithUTF8String:newViewProps.defaultValue.c_str()];
       [self importMarkdown:markdown];
     }
+  } else if (blockSyntaxChanged && _lastImportedMarkdown != nil) {
+    [self importMarkdown:_lastImportedMarkdown];
   }
 
   if (styleChanged) {
@@ -579,9 +597,11 @@ using namespace facebook::react;
       [self applyFormatting];
     }
 
-#if ENRICHED_MARKDOWN_MATH && !TARGET_OS_OSX
-    [self refreshAllMathChips];
-#endif
+    // Chips cache the style they were built with, so a style pass has to re-stamp
+    // them. Not gated on a style diff: every field is a flat scalar on
+    // `_formatterStyle`, so there is no cheap "did the math style change" test,
+    // and `refreshAll` already no-ops when the buffer holds no chip.
+    [_mathChipController refreshAll];
 
     [self requestHeightUpdate];
   } else if (writingDirectionChanged && _textView.textStorage.length > 0) {
@@ -605,20 +625,23 @@ using namespace facebook::react;
     return;
   }
 
-  dispatch_async(dispatch_get_main_queue(), ^{
-    NSUInteger textLength = self->_textView.textStorage.length;
-    if (textLength == 0) {
-      return;
-    }
-    NSRange wholeRange = NSMakeRange(0, textLength);
-    NSRange actualRange = NSMakeRange(0, 0);
-    [self->_textView.layoutManager invalidateLayoutForCharacterRange:wholeRange actualCharacterRange:&actualRange];
-    [self->_textView.layoutManager ensureLayoutForCharacterRange:actualRange];
-    [self->_textView.layoutManager invalidateDisplayForCharacterRange:wholeRange];
-
-    CGSize measuredSize = [self measureSize:self->_textView.frame.size.width];
-    ENRMSetContentSize(self->_textView, measuredSize);
-  });
+  NSUInteger textLength = _textView.textStorage.length;
+  if (textLength == 0) {
+    return;
+  }
+
+  NSRange wholeRange = NSMakeRange(0, textLength);
+  [_textView.layoutManager invalidateLayoutForCharacterRange:wholeRange actualCharacterRange:NULL];
+  [_textView.layoutManager ensureLayoutForTextContainer:_textView.textContainer];
+  [_textView.layoutManager invalidateDisplayForCharacterRange:wholeRange];
+
+  CGSize measuredSize = [self measureSize:_textView.frame.size.width];
+  CGSize currentSize = _textView.contentSize;
+  BOOL sizeChanged =
+      fabs(currentSize.width - measuredSize.width) > 0.5 || fabs(currentSize.height - measuredSize.height) > 0.5;
+  if (sizeChanged) {
+    ENRMSetContentSize(_textView, measuredSize);
+  }
 }
 
 #pragma mark - Window attachment
@@ -672,14 +695,6 @@ using namespace facebook::react;
   [_textView mouseDown:event];
 }
 
-#else // iOS
-
-- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
-    shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer
-{
-  return YES;
-}
-
 #endif
 
 #if !TARGET_OS_OSX
@@ -700,181 +715,178 @@ using namespace facebook::react;
 }
 #endif
 
+#pragma mark - ENRMEditPipelineHost
+
+/// Backs `onChangeText`. A math chip stays as its raw `kENRMObjectReplacement`
+/// character here — do not strip or expand it. `onChangeSelection`,
+/// `onCaretRectChange` and the three math commands all speak in buffer offsets
+/// where one formula is exactly one character, so removing it would put every
+/// offset JS holds out by one per chip, and expanding it to `$latex$` would be
+/// worse still. Use `onChangeMarkdown` when you want `$...$`.
+- (NSString *)plainText
+{
+  return ENRMGetPlainText(_textView);
+}
+
+- (NSTextStorage *)textStorage
+{
+  return _textView.textStorage;
+}
+
 #pragma mark - Placeholder
 
 - (void)updatePlaceholderVisibility
 {
-  _placeholderLabel.hidden = (ENRMGetPlainText(_textView).length > 0);
+  // Hide the placeholder once there's any content OR any block has been started
+  // (e.g. an empty bullet/heading line with only a zero-length anchor): the block
+  // marker or indent would otherwise overlap the placeholder text.
+  BOOL hasText = ENRMGetPlainText(_textView).length > 0;
+  BOOL hasBlock = _blockStore.allRanges.count > 0;
+  _placeholderLabel.hidden = hasText || hasBlock;
 }
 
 #pragma mark - Markdown import
 
 - (void)importMarkdown:(NSString *)markdown
 {
+  _lastImportedMarkdown = [markdown copy];
   ENRMInputParser *parser = [[ENRMInputParser alloc] init];
-  ENRMParseResult *parsed = [parser parseToPlainTextAndRanges:markdown];
+  ENRMParseResult *parsed = [parser parseToPlainTextAndRanges:markdown blockSyntax:_blockSyntax];
 
-  _blockEmitting = YES;
+  [_editSession enterPhase:ENRMEditPhaseImporting];
 
-  _isApplyingFormatting = YES;
+  [_editSession enterPhase:ENRMEditPhaseFormatting];
   ENRMSetPlainText(_textView, parsed.plainText);
+  [_editSession enterPhase:ENRMEditPhaseImporting];
 
-#if ENRICHED_MARKDOWN_MATH && !TARGET_OS_OSX
-  if (parsed.mathAtoms.count > 0) {
-    NSTextStorage *storage = _textView.textStorage;
-    [storage beginEditing];
-    for (ENRMMathAtom *atom in parsed.mathAtoms) {
-      if (atom.position >= storage.length)
-        continue;
-      unichar c = [storage.string characterAtIndex:atom.position];
-      if (c != (unichar)0xFFFC)
-        continue;
-      ENRMMathInlineAttachment *att = [self createMathAttachmentWithLatex:atom.latex displayMode:atom.displayMode];
-      NSAttributedString *replacement = [NSAttributedString attributedStringWithAttachment:att];
-      [storage replaceCharactersInRange:NSMakeRange(atom.position, 1) withAttributedString:replacement];
-      if (atom.displayMode && _formatterStyle.mathBlockAlignment != NSTextAlignmentNatural) {
-        NSMutableParagraphStyle *ps = [[NSMutableParagraphStyle alloc] init];
-        ps.alignment = _formatterStyle.mathBlockAlignment;
-        [storage addAttribute:NSParagraphStyleAttributeName value:ps range:NSMakeRange(atom.position, 1)];
-      }
-    }
-    [storage endEditing];
-  }
-#endif
-
-  _isApplyingFormatting = NO;
+  // Stamped inside the Importing phase, before the stores are read back: the
+  // parser already reserved one placeholder character per formula, so this only
+  // hangs an attachment on characters that are part of `parsed.plainText`. No
+  // deferral is needed the way Android needs one — `applyInputStyleProps` runs at
+  // the top of `updateProps`, so `_formatterStyle` is current before a
+  // `defaultValue` import ever reaches here.
+  [_mathChipController applyAtoms:parsed.mathAtoms offset:0];
 
   [_formattingStore setRanges:parsed.formattingRanges];
+  [_blockStore setRanges:parsed.blockRanges];
   _lastTextLength = parsed.plainText.length;
   _lastSelectedRange = _textView.selectedRange;
+
+  [_editSession exitPhase];
   [self applyFormatting];
   [self updatePlaceholderVisibility];
 
-  _blockEmitting = NO;
-}
-
-#if ENRICHED_MARKDOWN_MATH && !TARGET_OS_OSX
-
-- (void)applyMathStyleToAttachment:(ENRMMathInlineAttachment *)att
-{
-  if (att.displayMode) {
-    att.fontSize = _formatterStyle.mathBlockFontSize > 0 ? _formatterStyle.mathBlockFontSize : 20.0;
-    att.mathTextColor = _formatterStyle.mathBlockColor ?: _formatterStyle.baseTextColor;
-    att.containerBackgroundColor = _formatterStyle.mathBlockBackgroundColor;
-    att.containerBorderColor = _formatterStyle.mathBlockBorderColor;
-    att.containerBorderWidth = _formatterStyle.mathBlockBorderWidth;
-    att.containerBorderRadius = _formatterStyle.mathBlockBorderRadius;
-    att.containerPaddingHorizontal = _formatterStyle.mathBlockPaddingHorizontal;
-    att.containerPaddingVertical = _formatterStyle.mathBlockPaddingVertical;
-    att.blockMarginTop = _formatterStyle.mathBlockMarginTop;
-    att.blockMarginBottom = _formatterStyle.mathBlockMarginBottom;
-    att.blockAlignment = _formatterStyle.mathBlockAlignment;
-    att.selectedBackgroundColor = _formatterStyle.mathBlockSelectedBackgroundColor;
-    att.selectedBorderColor = _formatterStyle.mathBlockSelectedBorderColor;
-    att.bold = ENRMMathFontWeightIsBold(_formatterStyle.mathBlockFontWeight);
-  } else {
-    att.fontSize = _formatterStyle.mathFontSize > 0 ? _formatterStyle.mathFontSize : 16.0;
-    att.mathTextColor = _formatterStyle.mathColor ?: _formatterStyle.baseTextColor;
-    att.containerBackgroundColor = _formatterStyle.mathBackgroundColor;
-    att.containerBorderColor = _formatterStyle.mathBorderColor;
-    att.containerBorderWidth = _formatterStyle.mathBorderWidth;
-    att.containerBorderRadius = _formatterStyle.mathBorderRadius;
-    att.containerPaddingHorizontal = _formatterStyle.mathPaddingHorizontal;
-    att.containerPaddingVertical = _formatterStyle.mathPaddingVertical;
-    att.blockMarginTop = 0;
-    att.blockMarginBottom = 0;
-    att.blockAlignment = NSTextAlignmentNatural;
-    att.selectedBackgroundColor = _formatterStyle.mathSelectedBackgroundColor;
-    att.selectedBorderColor = _formatterStyle.mathSelectedBorderColor;
-    att.bold = ENRMMathFontWeightIsBold(_formatterStyle.mathFontWeight);
-  }
-}
-
-- (ENRMMathInlineAttachment *)createMathAttachmentWithLatex:(NSString *)latex displayMode:(BOOL)displayMode
-{
-  ENRMMathInlineAttachment *att = [[ENRMMathInlineAttachment alloc] init];
-  att.latex = latex ?: @"";
-  att.displayMode = displayMode;
-  [self applyMathStyleToAttachment:att];
-  return att;
-}
-
-- (void)refreshAllMathChips
-{
-  NSTextStorage *storage = _textView.textStorage;
-  if (storage.length == 0)
-    return;
-  __weak EnrichedMarkdownTextInput *weakSelf = self;
-  [storage beginEditing];
-  [storage enumerateAttribute:NSAttachmentAttributeName
-                      inRange:NSMakeRange(0, storage.length)
-                      options:0
-                   usingBlock:^(id value, NSRange range, BOOL *stop) {
-                     EnrichedMarkdownTextInput *strongSelf = weakSelf;
-                     if (!strongSelf)
-                       return;
-                     if ([value isKindOfClass:[ENRMMathInlineAttachment class]]) {
-                       ENRMMathInlineAttachment *att = value;
-                       [strongSelf applyMathStyleToAttachment:att];
-                       [att invalidateRender];
-                     }
-                   }];
-  [storage endEditing];
-
-  NSLayoutManager *lm = storage.layoutManagers.firstObject;
-  if (lm) {
-    NSRange fullRange = NSMakeRange(0, storage.length);
-    [lm invalidateLayoutForCharacterRange:fullRange actualCharacterRange:NULL];
-    [lm ensureLayoutForCharacterRange:fullRange];
+  if (parsed.plainText.length == 0) {
+    [self resetBaseTypingAttributes];
   }
-  ENRMSetNeedsDisplay(_textView);
 }
 
-#endif
-
 - (void)replaceTextInRange:(NSRange)selection
                   withText:(NSString *)text
           formattingRanges:(NSArray<ENRMFormattingRange *> *)ranges
+               blockRanges:(NSArray<ENRMBlockRange *> *)blockRanges
 {
   NSUInteger editLocation = selection.location;
 
-  _isApplyingFormatting = YES;
+  [_editSession enterPhase:ENRMEditPhaseFormatting];
   ENRMReplaceTextInRange(_textView, text, selection);
-  _isApplyingFormatting = NO;
+  [_editSession exitPhase];
 
-  [_formattingStore adjustForEditAtLocation:editLocation deletedLength:selection.length insertedLength:text.length];
+  NSString *plainText = [self adjustStoresForEditAtLocation:editLocation
+                                              deletedLength:selection.length
+                                             insertedLength:text.length];
 
   for (ENRMFormattingRange *range in ranges) {
     NSRange shifted = NSMakeRange(range.range.location + editLocation, range.range.length);
     [_formattingStore addRange:[ENRMFormattingRange rangeWithType:range.type range:shifted url:range.url]];
   }
 
-  _lastTextLength = ENRMGetPlainText(_textView).length;
+  for (ENRMBlockRange *block in blockRanges) {
+    NSRange shifted = NSMakeRange(block.range.location + editLocation, block.range.length);
+    [_blockStore setBlockType:block.type level:block.level forParagraphRange:shifted inText:plainText];
+  }
+
+  _lastTextLength = plainText.length;
   _lastSelectedRange = _textView.selectedRange;
 
   [self applyFormatting];
 
-  [_detectorPipeline processTextChange:ENRMGetPlainText(_textView)
-                     modificationRange:NSMakeRange(editLocation, text.length)];
+  [_detectorPipeline processTextChange:plainText modificationRange:NSMakeRange(editLocation, text.length)];
 
   [self updatePlaceholderVisibility];
-  [self emitOnChangeText];
-  [self emitOnChangeSelection];
-  [self emitFormattingChanged];
+  [_inputEventEmitter emitOnChangeText];
+  [_inputEventEmitter emitOnChangeSelection];
+  [_inputEventEmitter emitFormattingChanged];
   [self requestHeightUpdate];
   [self scheduleRelayoutIfNeeded];
 }
 
+- (void)replaceTextInRange:(NSRange)selection
+                  withText:(NSString *)text
+          formattingRanges:(NSArray<ENRMFormattingRange *> *)ranges
+{
+  [self replaceTextInRange:selection withText:text formattingRanges:ranges blockRanges:@[]];
+}
+
 - (void)replaceSelectedTextWith:(NSString *)text formattingRanges:(NSArray<ENRMFormattingRange *> *)ranges
 {
   [self replaceTextInRange:_textView.selectedRange withText:text formattingRanges:ranges];
 }
 
+/// 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, inserting "\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.
 - (void)pasteMarkdown:(NSString *)markdown
 {
+  NSUInteger lead = 0;
+  while (lead < markdown.length && [markdown characterAtIndex:lead] == '\n') {
+    lead++;
+  }
+  NSUInteger trail = 0;
+  while (lead + trail < markdown.length && [markdown characterAtIndex:markdown.length - 1 - trail] == '\n') {
+    trail++;
+  }
+  NSString *core = [markdown substringWithRange:NSMakeRange(lead, markdown.length - lead - trail)];
+
   ENRMInputParser *parser = [[ENRMInputParser alloc] init];
-  ENRMParseResult *parsed = [parser parseToPlainTextAndRanges:markdown];
-  [self replaceSelectedTextWith:parsed.plainText formattingRanges:parsed.formattingRanges];
+  ENRMParseResult *parsed = [parser parseToPlainTextAndRanges:core blockSyntax:_blockSyntax];
+
+  if (lead == 0 && trail == 0) {
+    NSUInteger insertLocation = _textView.selectedRange.location;
+    [self replaceTextInRange:_textView.selectedRange
+                    withText:parsed.plainText
+            formattingRanges:parsed.formattingRanges
+                 blockRanges:parsed.blockRanges];
+    // Positions are relative to the parsed fragment, so shift them onto the spot
+    // it landed. Pasted markdown carries formulas like any other source.
+    [_mathChipController applyAtoms:parsed.mathAtoms offset:insertLocation];
+    return;
+  }
+
+  NSString *prefix = [@"" stringByPaddingToLength:lead withString:@"\n" startingAtIndex:0];
+  NSString *suffix = [@"" stringByPaddingToLength:trail withString:@"\n" startingAtIndex:0];
+  NSString *plainText = [NSString stringWithFormat:@"%@%@%@", prefix, parsed.plainText, suffix];
+
+  NSMutableArray<ENRMFormattingRange *> *formattingRanges =
+      [NSMutableArray arrayWithCapacity:parsed.formattingRanges.count];
+  for (ENRMFormattingRange *range in parsed.formattingRanges) {
+    NSRange shifted = NSMakeRange(range.range.location + lead, range.range.length);
+    [formattingRanges addObject:[ENRMFormattingRange rangeWithType:range.type range:shifted url:range.url]];
+  }
+  NSMutableArray<ENRMBlockRange *> *blockRanges = [NSMutableArray arrayWithCapacity:parsed.blockRanges.count];
+  for (ENRMBlockRange *block in parsed.blockRanges) {
+    NSRange shifted = NSMakeRange(block.range.location + lead, block.range.length);
+    [blockRanges addObject:[ENRMBlockRange rangeWithType:block.type range:shifted level:block.level]];
+  }
+  NSUInteger insertLocation = _textView.selectedRange.location;
+  [self replaceTextInRange:_textView.selectedRange
+                  withText:plainText
+          formattingRanges:formattingRanges
+               blockRanges:blockRanges];
+  [_mathChipController applyAtoms:parsed.mathAtoms offset:insertLocation + lead];
 }
 
 #pragma mark - Formatting
@@ -889,17 +901,44 @@ using namespace facebook::react;
 
 - (void)applyFormatting
 {
-  if (_isApplyingFormatting) {
+  [self applyFormattingScopedToRange:NSMakeRange(0, ENRMGetPlainText(_textView).length)];
+}
+
+/// Per-keystroke variant: re-applies inline and block attributes only on the
+/// line(s) touched by the edit, mirroring Android's applyFormattingScopedToEdit.
+- (void)applyFormattingScopedToEditAtLocation:(NSUInteger)editLocation insertedLength:(NSUInteger)insertedLength
+{
+  NSString *plainText = ENRMGetPlainText(_textView);
+  NSUInteger textLength = plainText.length;
+  if (textLength == 0) {
+    [self applyFormatting];
+    return;
+  }
+
+  NSUInteger rawStart = MIN(editLocation, textLength);
+  NSUInteger rawEnd = MIN(editLocation + insertedLength, textLength);
+  rawEnd = MAX(rawEnd, rawStart);
+  NSRange scope = [plainText lineRangeForRange:NSMakeRange(rawStart, rawEnd - rawStart)];
+  [self applyFormattingScopedToRange:scope];
+}
+
+- (void)applyFormattingScopedToRange:(NSRange)scope
+{
+  if (_editSession.shouldSuppressFormatting) {
     return;
   }
-  if (ENRMHasMarkedText(_textView)) {
+  if (_editSession.isComposing) {
     return;
   }
-  _isApplyingFormatting = YES;
+  [_editSession enterPhase:ENRMEditPhaseFormatting];
 
   NSRange savedSelection = _textView.selectedRange;
 
-  [_formatter applyFormattingRanges:_formattingStore.allRanges toTextView:_textView style:_formatterStyle];
+  [_formatter applyFormattingRanges:_formattingStore.allRanges
+                         toTextView:_textView
+                              style:_formatterStyle
+                      scopedToRange:scope];
+  [_formatter applyBlockRanges:_blockStore.allRanges toTextView:_textView style:_formatterStyle scopedToRange:scope];
   [_detectorPipeline refreshAllStyling];
   [self applyWritingDirection];
 
@@ -908,7 +947,7 @@ using namespace facebook::react;
     _textView.selectedRange = savedSelection;
   }
 
-  _isApplyingFormatting = NO;
+  [_editSession exitPhase];
 }
 
 - (void)applyWritingDirection
@@ -938,9 +977,9 @@ using namespace facebook::react;
 {
   [self importMarkdown:markdown];
   _lastSelectedRange = _textView.selectedRange;
-  [self emitOnChangeText];
-  [self emitOnChangeSelection];
-  [self emitOnChangeState];
+  [_inputEventEmitter emitOnChangeText];
+  [_inputEventEmitter emitOnChangeSelection];
+  [_inputEventEmitter emitOnChangeState];
   [self requestHeightUpdate];
 }
 
@@ -950,8 +989,8 @@ using namespace facebook::react;
   NSInteger clampedStart = MIN(MAX(start, 0), textLen);
   NSInteger clampedEnd = MIN(MAX(end, clampedStart), textLen);
   _textView.selectedRange = NSMakeRange((NSUInteger)clampedStart, (NSUInteger)(clampedEnd - clampedStart));
-  [self emitOnChangeSelection];
-  [self emitOnChangeState];
+  [_inputEventEmitter emitOnChangeSelection];
+  [_inputEventEmitter emitOnChangeState];
 }
 
 - (void)toggleBold
@@ -988,813 +1027,817 @@ using namespace facebook::react;
   ENRMStyleMergingConfig *mergingConfig = handler.mergingConfig;
 
   NSRange selection = _textView.selectedRange;
-  NSUInteger cursor = selection.location;
-  NSNumber *key = @(styleType);
-
-  // Check blocking rules: if any blocking style is active, refuse to toggle on.
-  if (mergingConfig.blockingStyles.count > 0) {
-    BOOL isCurrentlyActive = [_formattingStore isStyleActive:styleType atPosition:cursor];
-    if (!isCurrentlyActive) {
-      for (NSNumber *blockerNum in mergingConfig.blockingStyles) {
-        if ([_formattingStore isStyleActive:(ENRMInputStyleType)blockerNum.integerValue atPosition:cursor]) {
-          return;
-        }
-      }
-    }
-  }
 
-  if (selection.length > 0) {
-    BOOL fullyStyled = YES;
-    NSUInteger pos = selection.location;
-    NSUInteger selEnd = NSMaxRange(selection);
-    while (pos < selEnd) {
-      ENRMFormattingRange *match = [_formattingStore rangeOfType:styleType containingPosition:pos];
-      if (match == nil) {
-        fullyStyled = NO;
-        break;
-      }
-      pos = NSMaxRange(match.range);
-    }
-    if (fullyStyled) {
-      [_formattingStore removeType:styleType inRange:selection];
-    } else {
-      // Remove conflicting styles from the range before applying.
-      for (NSNumber *conflictNum in mergingConfig.conflictingStyles) {
-        [_formattingStore removeType:(ENRMInputStyleType)conflictNum.integerValue inRange:selection];
-      }
-      ENRMFormattingRange *newRange = [ENRMFormattingRange rangeWithType:styleType range:selection];
-      [_formattingStore addRange:newRange];
-    }
-    [_pendingStyles removeObject:key];
-    [_pendingStyleRemovals removeObject:key];
-  } else {
-    BOOL isInsideRange = [_formattingStore isStyleActive:styleType atPosition:cursor];
-
-    if ([_pendingStyleRemovals containsObject:key]) {
-      [_pendingStyleRemovals removeObject:key];
-    } else if ([_pendingStyles containsObject:key]) {
-      [_pendingStyles removeObject:key];
-    } else if (isInsideRange) {
-      [_pendingStyleRemovals addObject:key];
-    } else {
-      [_pendingStyles addObject:key];
-    }
+  if ([_formattingStore isToggleBlocked:styleType
+                             atPosition:selection.location
+                         blockingStyles:mergingConfig.blockingStyles]) {
+    return;
   }
 
+  BOOL wasActive = [_formattingStore toggleStyle:styleType
+                                         inRange:selection
+                               conflictingStyles:mergingConfig.conflictingStyles];
+
+  [_typingController togglePendingStyle:styleType wasActive:wasActive hasSelection:(selection.length > 0)];
+
   [self applyFormatting];
-  [self syncTypingAttributesWithPendingStyles];
-  [self emitFormattingChanged];
+  [_typingController syncWithPendingStyles];
+  [_inputEventEmitter emitFormattingChanged];
 }
 
-- (void)setLink:(NSString *)url
+- (void)toggleHeading:(NSInteger)level
 {
-  NSRange selection = _textView.selectedRange;
-  NSUInteger cursor = selection.location;
+  if (level < 1 || level > 6) {
+    return;
+  }
+  [self toggleBlockType:ENRMBlockTypeForHeadingLevel(level) level:level];
+}
 
-  ENRMFormattingRange *activeLink = [_formattingStore rangeOfType:ENRMInputStyleTypeLink containingPosition:cursor];
+- (void)toggleBlockType:(ENRMInputBlockType)type level:(NSInteger)level
+{
+  NSString *text = ENRMGetPlainText(_textView);
+  BOOL alreadyActive = [_blockCoordinator toggleBlockType:type
+                                                    level:level
+                                           selectionRange:_textView.selectedRange
+                                                   inText:text];
 
-  if (activeLink != nil) {
-    activeLink.url = url;
-    [_autoLinkDetector clearAutoLinkInRange:activeLink.range];
-  } else if (selection.length > 0) {
-    ENRMFormattingRange *linkRange = [ENRMFormattingRange rangeWithType:ENRMInputStyleTypeLink range:selection url:url];
-    [_formattingStore addRange:linkRange];
-    [_autoLinkDetector clearAutoLinkInRange:selection];
-  } else {
-    return;
+  if (alreadyActive) {
+    // Strip the stored block paragraph style directly: an empty item's line has no
+    // stamped block-marker attribute (zero-length ranges are never stamped), so the
+    // applyFormatting reset below — which is keyed off that marker — cannot reach it.
+    NSRange paragraphRange = [text paragraphRangeForRange:_textView.selectedRange];
+    NSTextStorage *storage = _textView.textStorage;
+    NSRange clamped = NSIntersectionRange(paragraphRange, NSMakeRange(0, storage.length));
+    if (clamped.length > 0) {
+      [storage beginEditing];
+      [storage removeAttribute:NSParagraphStyleAttributeName range:clamped];
+      [storage endEditing];
+    }
   }
 
   [self applyFormatting];
-  [self emitFormattingChanged];
+  [_typingController syncWithCursorBlock];
+  [self updatePlaceholderVisibility];
+  if (alreadyActive) {
+    [_typingController clearListParagraphStyle];
+  }
+  [self updateEmptyBulletMarker];
+  [_inputEventEmitter emitFormattingChanged];
 }
 
-- (void)insertLink:(NSString *)text url:(NSString *)url
+- (void)toggleUnorderedList
 {
-  NSString *displayText = text.length > 0 ? text : url;
-  NSRange linkRange = NSMakeRange(0, displayText.length);
-  ENRMFormattingRange *range = [ENRMFormattingRange rangeWithType:ENRMInputStyleTypeLink
-                                                            range:linkRange
-                                                              url:[self sanitizeLinkURL:url]];
-  [self replaceSelectedTextWith:displayText formattingRanges:@[ range ]];
+  [self toggleBlockType:ENRMInputBlockTypeUnorderedListItem level:0];
 }
 
-- (NSString *)sanitizeLinkURL:(NSString *)url
+- (void)toggleOrderedList
 {
-  NSString *result = [url stringByReplacingOccurrencesOfString:@"(" withString:@"%28"];
-  return [result stringByReplacingOccurrencesOfString:@")" withString:@"%29"];
+  [self toggleBlockType:ENRMInputBlockTypeOrderedListItem level:0];
 }
 
-- (void)startMention:(NSString *)indicator
+- (void)indentList
 {
-  if (indicator.length == 0 || ![_mentionIndicators containsObject:indicator]) {
-    return;
-  }
-
-  [self replaceSelectedTextWith:indicator formattingRanges:@[]];
-  [self updateActiveMention];
+  [self changeListDepthBy:1];
 }
 
-- (void)insertMention:(NSString *)displayText url:(NSString *)url
+- (void)outdentList
 {
-  if (displayText.length == 0 || _activeMentionIndicator == nil || _activeMentionRange.location == NSNotFound) {
-    return;
-  }
+  [self changeListDepthBy:-1];
+}
 
-  NSString *plainText = ENRMGetPlainText(_textView);
-  NSUInteger rangeEnd = NSMaxRange(_activeMentionRange);
-  if (rangeEnd > plainText.length) {
+- (void)changeListDepthBy:(NSInteger)delta
+{
+  NSString *text = ENRMGetPlainText(_textView);
+  ENRMDepthChangeResult result = [_blockCoordinator changeDepthBy:delta
+                                                   cursorPosition:_textView.selectedRange.location
+                                                   selectionRange:_textView.selectedRange
+                                                           inText:text];
+  if (result == ENRMDepthChangeResultNoOp) {
     return;
   }
-  BOOL nextCharIsWhitespace = rangeEnd < plainText.length && [[NSCharacterSet whitespaceAndNewlineCharacterSet]
-                                                                 characterIsMember:[plainText
-                                                                                       characterAtIndex:rangeEnd]];
-  NSString *replacement = nextCharIsWhitespace ? displayText : [displayText stringByAppendingString:@" "];
-  ENRMFormattingRange *linkRange = [ENRMFormattingRange rangeWithType:ENRMInputStyleTypeLink
-                                                                range:NSMakeRange(0, displayText.length)
-                                                                  url:[self sanitizeLinkURL:url]];
-  NSString *indicator = _activeMentionIndicator;
-  NSRange mentionRange = _activeMentionRange;
+  [self applyFormatting];
+  [_typingController syncWithCursorBlock];
+  [self updateEmptyBulletMarker];
+  [_inputEventEmitter emitFormattingChanged];
+}
 
-  [self clearActiveMention:indicator];
-  [self replaceTextInRange:mentionRange withText:replacement formattingRanges:@[ linkRange ]];
-  _textView.selectedRange = NSMakeRange(mentionRange.location + replacement.length, 0);
-  [self emitOnChangeSelection];
+- (nullable ENRMBlockRange *)listBlockForCursorParagraph
+{
+  return [self listBlockForParagraphAtPosition:_textView.selectedRange.location];
 }
 
-- (void)removeLink
+- (nullable ENRMBlockRange *)listBlockForParagraphAtPosition:(NSUInteger)position
 {
-  NSUInteger cursor = _textView.selectedRange.location;
-  ENRMFormattingRange *activeLink = [_formattingStore rangeOfType:ENRMInputStyleTypeLink containingPosition:cursor];
-  if (activeLink == nil) {
-    return;
-  }
+  return [_blockCoordinator listBlockAtPosition:position inText:_textView.textStorage.string];
+}
 
-  [_formattingStore removeRange:activeLink];
-  [self applyFormatting];
-  [self emitFormattingChanged];
+- (nullable ENRMBlockRange *)blockForParagraphAtPosition:(NSUInteger)position
+{
+  return [_blockCoordinator blockAtPosition:position inText:_textView.textStorage.string];
 }
 
-#pragma mark - Math chip commands
+- (BOOL)listStateOfType:(ENRMInputBlockType)type forCursorParagraphDepth:(nullable NSInteger *)outDepth
+{
+  return [_blockCoordinator listStateOfType:type
+                                 atPosition:_textView.selectedRange.location
+                                     inText:_textView.textStorage.string
+                                      depth:outDepth];
+}
 
-- (void)insertMath:(NSString *)latex displayMode:(BOOL)displayMode
+/// Records the block kind/level of the line being edited before the change, so a
+/// Return that continues a list can recover the previous item's depth and an
+/// in-line replacement (autocorrect/paste) that wipes the line can heal it.
+- (void)capturePreEditBlockForRange:(NSRange)range
 {
-#if ENRICHED_MARKDOWN_MATH && !TARGET_OS_OSX
-  if (latex.length == 0)
-    return;
-  NSTextStorage *storage = _textView.textStorage;
-  NSRange selection = _textView.selectedRange;
-  NSString *plainText = ENRMGetPlainText(_textView);
+  ENRMBlockRange *block = [self blockForParagraphAtPosition:range.location];
+  _preEditBlockType = block != nil ? block.type : ENRMInputBlockTypeParagraph;
+  _preEditBlockLevel = block != nil ? block.level : 0;
+}
 
-  NSMutableString *prefix = [NSMutableString string];
-  NSMutableString *suffix = [NSMutableString string];
-  if (displayMode) {
-    BOOL atLineStart = (selection.location == 0) || [plainText characterAtIndex:selection.location - 1] == '\n';
-    NSUInteger afterSel = selection.location + selection.length;
-    BOOL atLineEnd = (afterSel >= plainText.length) || [plainText characterAtIndex:afterSel] == '\n';
-    if (!atLineStart)
-      [prefix appendString:@"\n"];
-    if (!atLineEnd)
-      [suffix appendString:@"\n"];
+/// Whether `range` of the current (pre-edit) text contains a line break. Scans
+/// only the replaced run, mirroring Android's editTouchedNewline.
+- (BOOL)replacedRangeTouchesNewline:(NSRange)range
+{
+  NSString *text = _textView.textStorage.string;
+  if (range.length == 0 || range.location >= text.length) {
+    return NO;
   }
+  NSRange clamped = NSMakeRange(range.location, MIN(range.length, text.length - range.location));
+  return [text rangeOfCharacterFromSet:[NSCharacterSet newlineCharacterSet] options:0 range:clamped].location !=
+         NSNotFound;
+}
 
-  ENRMMathInlineAttachment *att = [self createMathAttachmentWithLatex:latex displayMode:displayMode];
-  NSMutableAttributedString *replacement = [[NSMutableAttributedString alloc] init];
-  if (prefix.length) {
-    [replacement appendAttributedString:[[NSAttributedString alloc] initWithString:prefix]];
+/// Whether the caret's paragraph had no glyph content at the start of the edit
+/// (an empty line). Used to decide whether Return continues or exits the list.
+- (BOOL)preEditParagraphWasEmpty:(NSRange)range
+{
+  NSString *text = _textView.textStorage.string;
+  if (text.length == 0) {
+    return YES;
   }
-  [replacement appendAttributedString:[NSAttributedString attributedStringWithAttachment:att]];
-  if (suffix.length) {
-    [replacement appendAttributedString:[[NSAttributedString alloc] initWithString:suffix]];
+  NSRange paragraph = [text paragraphRangeForRange:range];
+  if (paragraph.length == 0) {
+    return YES;
   }
+  return [[text substringWithRange:paragraph] isEqualToString:@"\n"];
+}
 
-  if (displayMode && att.blockAlignment != NSTextAlignmentNatural) {
-    NSMutableParagraphStyle *ps = [[NSMutableParagraphStyle alloc] init];
-    ps.alignment = att.blockAlignment;
-    NSRange chipRange = NSMakeRange(prefix.length, 1);
-    [replacement addAttribute:NSParagraphStyleAttributeName value:ps range:chipRange];
+/// Intercepts Tab (indent) and Backspace at a bullet item's start (outdent, then
+/// un-list at depth 0). Returns YES when handled, suppressing the default edit.
+/// Keyed off the caret's own paragraph (NSMaxRange(range)), not range.location —
+/// a backspace at a line start targets the previous line's newline, and using the
+/// caret's line lets the next Backspace after un-listing fall through to a merge.
+- (BOOL)handleListKeyForReplacementRange:(NSRange)range replacementText:(NSString *)text
+{
+  NSUInteger caret = NSMaxRange(range);
+  NSInteger depth;
+  if (![self listStateForParagraphAtPosition:caret depth:&depth]) {
+    return NO;
   }
 
-  _isApplyingFormatting = YES;
-  [storage replaceCharactersInRange:selection withAttributedString:replacement];
-  _isApplyingFormatting = NO;
-
-  NSUInteger insertedLength = replacement.length;
-  [_formattingStore adjustForEditAtLocation:selection.location
-                              deletedLength:selection.length
-                             insertedLength:insertedLength];
+  // Tab indents the current item.
+  if ([text isEqualToString:@"\t"]) {
+    [self indentList];
+    return YES;
+  }
 
-  NSUInteger newCursor = selection.location + insertedLength;
-  _textView.selectedRange = NSMakeRange(newCursor, 0);
-  _lastTextLength = ENRMGetPlainText(_textView).length;
-  _lastSelectedRange = _textView.selectedRange;
+  // Backspace at the very start of the caret's own item: outdent, or remove the
+  // marker entirely once at depth 0 (de-indenting the line to a plain paragraph).
+  if (text.length == 0 && range.length == 1) {
+    NSString *plainText = ENRMGetPlainText(_textView);
+    NSRange paragraphRange = [plainText paragraphRangeForRange:NSMakeRange(caret, 0)];
+    BOOL atItemStart = caret == paragraphRange.location;
+    if (atItemStart) {
+      if (depth > 0) {
+        [self outdentList];
+      } else {
+        ENRMBlockRange *listBlock = [self listBlockForParagraphAtPosition:caret];
+        [self toggleBlockType:listBlock != nil ? listBlock.type : ENRMInputBlockTypeUnorderedListItem level:0];
+      }
+      return YES;
+    }
+  }
 
-  [self applyFormatting];
-  [self updatePlaceholderVisibility];
-  [self emitOnChangeText];
-  [self emitOnChangeSelection];
-  [self emitFormattingChanged];
-  [self requestHeightUpdate];
-  [self scheduleRelayoutIfNeeded];
-#endif
+  return NO;
 }
 
-- (void)updateMath:(NSInteger)start latex:(NSString *)latex displayMode:(BOOL)displayMode
+/// Backspace at the document start (caret at 0) never fires the text-change
+/// delegate — nothing precedes the caret — so the first line's bullet has to be
+/// outdented/removed here. Returns YES when handled.
+- (BOOL)handleBackspaceAtDocumentStart
 {
-#if ENRICHED_MARKDOWN_MATH && !TARGET_OS_OSX
-  NSTextStorage *storage = _textView.textStorage;
-  if (start < 0 || (NSUInteger)start >= storage.length)
-    return;
-  id value = [storage attribute:NSAttachmentAttributeName atIndex:(NSUInteger)start effectiveRange:NULL];
-  if (![value isKindOfClass:[ENRMMathInlineAttachment class]])
-    return;
-
-  ENRMMathInlineAttachment *att = value;
-  BOOL modeChanged = (att.displayMode != displayMode);
-  att.latex = latex ?: @"";
-  att.displayMode = displayMode;
-  [self applyMathStyleToAttachment:att];
-  [att invalidateRender];
-
-  NSRange chipRange = NSMakeRange((NSUInteger)start, 1);
-  if (modeChanged) {
-    [storage beginEditing];
-    if (displayMode && att.blockAlignment != NSTextAlignmentNatural) {
-      NSMutableParagraphStyle *ps = [[NSMutableParagraphStyle alloc] init];
-      ps.alignment = att.blockAlignment;
-      [storage addAttribute:NSParagraphStyleAttributeName value:ps range:chipRange];
-    } else {
-      [storage removeAttribute:NSParagraphStyleAttributeName range:chipRange];
-    }
-    [storage endEditing];
+  NSRange selection = _textView.selectedRange;
+  if (selection.location != 0 || selection.length != 0) {
+    return NO;
   }
-
-  NSLayoutManager *lm = storage.layoutManagers.firstObject;
-  if (lm) {
-    [lm invalidateLayoutForCharacterRange:chipRange actualCharacterRange:NULL];
-    [lm ensureLayoutForCharacterRange:chipRange];
+  ENRMBlockRange *listBlock = [self listBlockForCursorParagraph];
+  if (listBlock == nil) {
+    return NO;
   }
-  ENRMSetNeedsDisplay(_textView);
-
-  if (_emitMarkdown) {
-    [self emitOnChangeMarkdown];
+  if (listBlock.level > 0) {
+    [self outdentList];
+  } else {
+    [self toggleBlockType:listBlock.type level:0];
   }
-  [self requestHeightUpdate];
-  [self scheduleRelayoutIfNeeded];
-#endif
+  return YES;
 }
 
-- (void)removeMath:(NSInteger)start
+- (BOOL)listStateForParagraphAtPosition:(NSUInteger)position depth:(NSInteger *)outDepth
 {
-#if ENRICHED_MARKDOWN_MATH && !TARGET_OS_OSX
-  NSTextStorage *storage = _textView.textStorage;
-  if (start < 0 || (NSUInteger)start >= storage.length)
-    return;
-  id value = [storage attribute:NSAttachmentAttributeName atIndex:(NSUInteger)start effectiveRange:NULL];
-  if (![value isKindOfClass:[ENRMMathInlineAttachment class]])
-    return;
-
-  [self replaceTextInRange:NSMakeRange((NSUInteger)start, 1) withText:@"" formattingRanges:@[]];
-#endif
+  ENRMBlockRange *block = [_blockCoordinator listBlockAtPosition:position inText:_textView.textStorage.string];
+  if (block != nil) {
+    if (outDepth) {
+      *outDepth = block.level;
+    }
+    return YES;
+  }
+  return NO;
 }
 
-- (void)showLinkPrompt
+/// Drives the layout manager's empty-line bullet: an empty bullet line has no
+/// character to anchor the marker to, so the manager is told its location/depth
+/// explicitly; cleared when the caret isn't on an empty bullet line. Runs on
+/// every selection-change fire, so it early-returns when there is nothing to
+/// draw or clear and only touches storage when the paragraph style differs,
+/// avoiding layout churn that jitters the edit menu.
+- (void)updateEmptyBulletMarker
 {
-  NSUInteger cursor = _textView.selectedRange.location;
-  ENRMFormattingRange *activeLink = [_formattingStore rangeOfType:ENRMInputStyleTypeLink containingPosition:cursor];
-  NSString *existingURL = activeLink != nil ? activeLink.url : nil;
+  NSString *text = ENRMGetPlainText(_textView);
+  NSRange selection = _textView.selectedRange;
+  BOOL show = NO;
+  NSUInteger location = 0;
+  NSInteger depth = 0;
 
-  __weak EnrichedMarkdownTextInput *weakSelf = self;
-  ENRMShowLinkPrompt(self, existingURL, ^(NSString *url) { [weakSelf setLink:url]; });
-}
+  BOOL ordered = NO;
+  NSInteger ordinal = 1;
+  ENRMBlockRange *cursorListBlock = selection.length == 0 ? [self listBlockForCursorParagraph] : nil;
 
-- (nullable NSString *)markdownForSelectedRange
-{
-  NSRange selection = _textView.selectedRange;
-  if (selection.length == 0) {
-    return nil;
+  ENRMInputListMarkerDrawer *listDrawer = _layoutManager.listMarkerDrawer;
+  BOOL wasShown = listDrawer.emptyBulletDepth >= 0;
+  if (cursorListBlock == nil && !wasShown) {
+    return;
   }
 
-  NSAttributedString *full = _textView.textStorage;
-  if (NSMaxRange(selection) > full.length) {
-    return nil;
+  if (cursorListBlock != nil) {
+    NSInteger cursorDepth = cursorListBlock.level;
+    ordered = cursorListBlock.type == ENRMInputBlockTypeOrderedListItem;
+    ordinal = cursorListBlock.ordinal;
+    NSRange paragraphRange = text.length == 0 ? NSMakeRange(0, 0) : [text paragraphRangeForRange:selection];
+    NSString *paragraphText = text.length == 0 ? @"" : [text substringWithRange:paragraphRange];
+    BOOL empty = paragraphText.length == 0 || [paragraphText isEqualToString:@"\n"];
+    if (empty) {
+      show = YES;
+      location = paragraphRange.location;
+      depth = cursorDepth;
+
+      // A mid-document empty bullet line has no paragraph style and lays out
+      // flush left; stamp the list style so caret and marker indent immediately.
+      // (A trailing empty line uses the extra line fragment instead.)
+      if (paragraphRange.length > 0) {
+        CGFloat indent = (depth + 1) * kENRMListIndentPerDepth;
+        NSTextStorage *storage = _textView.textStorage;
+        NSParagraphStyle *existing = [storage attribute:NSParagraphStyleAttributeName
+                                                atIndex:paragraphRange.location
+                                         effectiveRange:NULL];
+        if (existing == nil || existing.firstLineHeadIndent != indent || existing.headIndent != indent ||
+            existing.paragraphSpacingBefore != _formatterStyle.listItemSpacing) {
+          NSMutableParagraphStyle *paragraph = [[NSMutableParagraphStyle alloc] init];
+          paragraph.firstLineHeadIndent = indent;
+          paragraph.headIndent = indent;
+          paragraph.paragraphSpacingBefore = _formatterStyle.listItemSpacing;
+          [storage beginEditing];
+          [storage addAttribute:NSParagraphStyleAttributeName value:paragraph range:paragraphRange];
+          [storage endEditing];
+        }
+      }
+    }
   }
-  NSAttributedString *selectedAttr = [full attributedSubstringFromRange:selection];
-  NSUInteger selEnd = NSMaxRange(selection);
 
-  NSMutableArray<ENRMFormattingRange *> *clippedRanges = [NSMutableArray array];
-  for (ENRMFormattingRange *range in [self allRangesIncludingTransient]) {
-    NSUInteger rangeStart = range.range.location;
-    NSUInteger rangeEnd = NSMaxRange(range.range);
+  if (!show && !wasShown) {
+    return;
+  }
 
-    if (rangeEnd <= selection.location || rangeStart >= selEnd) {
-      continue;
-    }
+  listDrawer.emptyBulletDepth = show ? depth : -1;
+  listDrawer.emptyBulletOrdered = ordered;
+  listDrawer.emptyBulletOrdinal = ordinal;
+  listDrawer.emptyBulletLocation = location;
+  listDrawer.emptyBulletFont = _formatterStyle.baseFont;
+  listDrawer.emptyBulletColor = _formatterStyle.baseTextColor;
+  listDrawer.emptyBulletRTL = [self emptyListLineIsRTL];
+  listDrawer.listItemSpacing = _formatterStyle.listItemSpacing;
 
-    NSUInteger clippedStart = MAX(rangeStart, selection.location);
-    NSUInteger clippedEnd = MIN(rangeEnd, selEnd);
-    NSRange shifted = NSMakeRange(clippedStart - selection.location, clippedEnd - clippedStart);
+  BOOL isTrailing = show && text.length > 0 && location >= text.length;
 
-    [clippedRanges addObject:[ENRMFormattingRange rangeWithType:range.type range:shifted url:range.url]];
+  // Ensure the extra line fragment is laid out so we can read
+  // extraLineFragmentTextContainer / extraLineFragmentUsedRect.  The
+  // empty-editor case (length 0) has no glyphs at all; the trailing-line case
+  // (location >= length) has glyphs on preceding lines but the extra line
+  // fragment lives beyond them and isn't covered by ensureLayoutForCharRange:.
+  if (show && (text.length == 0 || location >= text.length)) {
+    [_layoutManager ensureLayoutForTextContainer:_textView.textContainer];
   }
 
-  return [ENRMMarkdownSerializer serializeAttributedString:selectedAttr ranges:clippedRanges];
+#if !TARGET_OS_OSX
+  if (isTrailing && _layoutManager.extraLineFragmentTextContainer != nil) {
+    [listDrawer showTrailingBulletInTextView:_textView
+                               textContainer:_layoutManager.extraLineFragmentTextContainer
+                                    usedRect:_layoutManager.extraLineFragmentUsedRect];
+  } else {
+    [listDrawer hideTrailingBullet];
+  }
+#endif
+
+  ENRMSetNeedsDisplay(_textView);
+
+  // The empty-editor bullet would otherwise overlap the placeholder.
+  [self updatePlaceholderVisibility];
 }
 
-- (void)copyToClipboard
+/// Writing direction the empty list line resolves to, for mirroring its marker.
+/// An empty line has no strong character, so Auto and FirstStrong fall back the
+/// same way the formatter's direction pass would.
+- (BOOL)emptyListLineIsRTL
 {
-  NSString *plainText = ENRMGetPlainText(_textView);
-  if (plainText.length == 0) {
-    return;
-  }
-  NSString *markdown = [ENRMMarkdownSerializer serializePlainText:plainText ranges:[self allRangesIncludingTransient]];
-  NSMutableDictionary *items = [NSMutableDictionary dictionary];
-  items[kUTIPlainText] = plainText;
-  if (markdown.length > 0) {
-    items[kENRMMarkdownPasteboardType] = markdown;
+  switch (_writingDirectionMode) {
+    case ENRMWritingDirectionModeLTR:
+      return NO;
+    case ENRMWritingDirectionModeRTL:
+      return YES;
+    case ENRMWritingDirectionModeFirstStrong:
+      return _resolvedLayoutDirection == NSWritingDirectionRightToLeft;
+    case ENRMWritingDirectionModeAuto:
+    default:
+      return ENRMParagraphIsRTL(nil);
   }
-  copyItemsToPasteboard(items);
 }
 
-- (void)requestMarkdown:(NSInteger)requestId
+- (NSInteger)headingLevelForCursorParagraph
 {
-  auto emitter = [self getEventEmitter];
-  if (emitter == nullptr) {
-    return;
-  }
-  NSString *markdown = [ENRMMarkdownSerializer serializeAttributedString:_textView.textStorage
-                                                                  ranges:[self allRangesIncludingTransient]];
-  emitter->onRequestMarkdownResult({
-      .requestId = static_cast<int>(requestId),
-      .markdown = std::string([markdown UTF8String] ?: ""),
-  });
+  return [_blockCoordinator headingLevelAtPosition:_textView.selectedRange.location
+                                            inText:_textView.textStorage.string];
 }
 
-- (CGRect)computeCaretRect
+- (NSString *)adjustStoresForEditAtLocation:(NSUInteger)editLocation
+                              deletedLength:(NSUInteger)deletedLength
+                             insertedLength:(NSUInteger)insertedLength
 {
-  CGRect caretRect = CGRectZero;
-#if !TARGET_OS_OSX
-  UITextRange *selectedRange = _textView.selectedTextRange;
-  if (selectedRange != nil) {
-    caretRect = [_textView caretRectForPosition:selectedRange.start];
-  }
-#else
-  NSRange selection = _textView.selectedRange;
-  if (selection.location != NSNotFound) {
-    NSRange glyphRange = [_textView.layoutManager glyphRangeForCharacterRange:NSMakeRange(selection.location, 0)
-                                                         actualCharacterRange:NULL];
-    caretRect = [_textView.layoutManager boundingRectForGlyphRange:glyphRange inTextContainer:_textView.textContainer];
-    caretRect.origin.x += _textView.textContainerInset.left;
-    caretRect.origin.y += _textView.textContainerInset.top;
-  }
-#endif
-  return caretRect;
+  return [_editPipeline adjustStoresForEditAtLocation:editLocation
+                                        deletedLength:deletedLength
+                                       insertedLength:insertedLength];
 }
 
-- (void)requestCaretRect:(NSInteger)requestId
+- (void)setLink:(NSString *)url
 {
-  auto emitter = [self getEventEmitter];
-  if (emitter == nullptr) {
+  NSRange selection = _textView.selectedRange;
+  if (![_linkCoordinator setLinkURL:url atCursor:selection.location selection:selection]) {
     return;
   }
-
-  CGRect caretRect = [self computeCaretRect];
-  emitter->onRequestCaretRectResult({
-      .requestId = static_cast<int>(requestId),
-      .x = caretRect.origin.x,
-      .y = caretRect.origin.y,
-      .width = caretRect.size.width,
-      .height = caretRect.size.height,
-  });
+  [self applyFormatting];
+  [_inputEventEmitter emitFormattingChanged];
 }
 
-- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+- (void)insertLink:(NSString *)text url:(NSString *)url
 {
-  RCTEnrichedMarkdownTextInputHandleCommand(self, commandName, args);
+  NSString *displayText = text.length > 0 ? text : url;
+  NSRange linkRange = NSMakeRange(0, displayText.length);
+  ENRMFormattingRange *range = [ENRMFormattingRange rangeWithType:ENRMInputStyleTypeLink
+                                                            range:linkRange
+                                                              url:[_linkCoordinator sanitizeURL:url]];
+  [self replaceSelectedTextWith:displayText formattingRanges:@[ range ]];
 }
 
-#pragma mark - Style state query
-
-- (BOOL)isEffectiveStyleActive:(ENRMInputStyleType)type atPosition:(NSUInteger)position
+- (void)insertText:(NSString *)text
 {
-  BOOL inRange = [_formattingStore isStyleActive:type atPosition:position];
-  NSNumber *key = @(type);
-  if ([_pendingStyleRemovals containsObject:key]) {
-    return NO;
-  }
-  if ([_pendingStyles containsObject:key]) {
-    return YES;
+  if (text.length == 0) {
+    return;
   }
-  return inRange;
+  [self pasteMarkdown:text];
 }
 
-- (void)syncTypingAttributesWithPendingStyles
+- (void)startMention:(NSString *)indicator
 {
-  UIFontDescriptorSymbolicTraits traits = 0;
-  if ([_pendingStyles containsObject:@(ENRMInputStyleTypeStrong)]) {
-    traits |= UIFontDescriptorTraitBold;
-  }
-  if ([_pendingStyles containsObject:@(ENRMInputStyleTypeEmphasis)]) {
-    traits |= UIFontDescriptorTraitItalic;
+  if (indicator.length == 0 || ![_mentionCoordinator containsIndicator:indicator]) {
+    return;
   }
 
-  NSMutableDictionary *attrs = [_textView.typingAttributes mutableCopy];
-  attrs[NSFontAttributeName] = [_formatterStyle fontForTraits:traits];
-  _textView.typingAttributes = attrs;
+  [self replaceSelectedTextWith:indicator formattingRanges:@[]];
+  [self dispatchMentionUpdate];
 }
 
-- (void)resetPendingStylesForSelectionChange
+- (void)insertMention:(NSString *)displayText url:(NSString *)url
 {
-  // Skip system-driven selection adjustments (e.g., predictive text) that fire
-  // immediately after a text edit.
-  static const CFTimeInterval kPostEditGracePeriod = 0.1;
-  BOOL isPostEditAdjustment =
-      (_lastTextChangeTime > 0 && (CACurrentMediaTime() - _lastTextChangeTime) < kPostEditGracePeriod);
-  if (isPostEditAdjustment) {
+  if (displayText.length == 0 || !_mentionCoordinator.isActive ||
+      _mentionCoordinator.activeRange.location == NSNotFound) {
     return;
   }
-  [_pendingStyles removeAllObjects];
-  [_pendingStyleRemovals removeAllObjects];
-  [self rebuildPendingStylesFromContext];
-  [self syncTypingAttributesWithPendingStyles];
-}
 
-- (void)rebuildPendingStylesFromContext
-{
-  NSUInteger cursor = _textView.selectedRange.location;
-  if (_textView.selectedRange.length > 0 || cursor == 0) {
+  NSString *plainText = ENRMGetPlainText(_textView);
+  NSRange activeRange = _mentionCoordinator.activeRange;
+  NSUInteger rangeEnd = NSMaxRange(activeRange);
+  if (rangeEnd > plainText.length) {
     return;
   }
+  BOOL nextCharIsWhitespace = rangeEnd < plainText.length && [[NSCharacterSet whitespaceAndNewlineCharacterSet]
+                                                                 characterIsMember:[plainText
+                                                                                       characterAtIndex:rangeEnd]];
+  NSString *replacement = nextCharIsWhitespace ? displayText : [displayText stringByAppendingString:@" "];
+  ENRMFormattingRange *linkRange = [ENRMFormattingRange rangeWithType:ENRMInputStyleTypeLink
+                                                                range:NSMakeRange(0, displayText.length)
+                                                                  url:[_linkCoordinator sanitizeURL:url]];
+  NSString *indicator = _mentionCoordinator.activeIndicator;
 
-  static const ENRMInputStyleType inlineStyles[] = {
-      ENRMInputStyleTypeStrong,        ENRMInputStyleTypeEmphasis, ENRMInputStyleTypeUnderline,
-      ENRMInputStyleTypeStrikethrough, ENRMInputStyleTypeSpoiler,
-  };
-
-  for (NSUInteger i = 0; i < sizeof(inlineStyles) / sizeof(inlineStyles[0]); i++) {
-    ENRMInputStyleType type = inlineStyles[i];
-    if ([_formattingStore isStyleAdjacentBefore:type position:cursor]) {
-      [_pendingStyles addObject:@(type)];
-    }
-  }
+  [self dispatchMentionEvents:[_mentionCoordinator clearWithIndicatorOverride:indicator]];
+  [self replaceTextInRange:activeRange withText:replacement formattingRanges:@[ linkRange ]];
+  _textView.selectedRange = NSMakeRange(activeRange.location + replacement.length, 0);
+  [_inputEventEmitter emitOnChangeSelection];
 }
 
-#pragma mark - Event emitters
-
-- (void)emitFormattingChanged
+- (void)removeLink
 {
-  [self emitOnChangeState];
-  if (_emitMarkdown) {
-    [self emitOnChangeMarkdown];
+  if (![_linkCoordinator removeLinkAtPosition:_textView.selectedRange.location]) {
+    return;
   }
+  [self applyFormatting];
+  [_inputEventEmitter emitFormattingChanged];
 }
 
-- (std::shared_ptr<EnrichedMarkdownTextInputEventEmitter const>)getEventEmitter
+#pragma mark - Math chip commands
+
+// A chip is one U+FFFC character in the buffer plus an ENRMMathInlineAttachment
+// carrying the LaTeX (see ENRMMathChipController). Every text mutation below goes
+// through the same replaceTextInRange/EditPhase machinery as links and mentions —
+// a chip is an atomic inline character, not a block, so it needs no ENRMBlockHandler
+// and no phase of its own.
+//
+// No ENRICHED_MARKDOWN_MATH guard here on purpose: codegen declares these three on
+// RCTEnrichedMarkdownTextInputViewProtocol regardless of the math flag, and
+// RCTEnrichedMarkdownTextInputHandleCommand sends the selector unconditionally, so
+// conformance must hold in math-disabled builds. The controller is inert there.
+
+- (void)insertMath:(NSString *)latex displayMode:(BOOL)displayMode
 {
-  if (_eventEmitter == nullptr || _blockEmitting) {
-    return nullptr;
+  if (latex.length == 0 || !ENRMMathChipController.isAvailable) {
+    return;
   }
-  return std::static_pointer_cast<EnrichedMarkdownTextInputEventEmitter const>(_eventEmitter);
-}
 
-- (NSArray<ENRMFormattingRange *> *)allRangesIncludingTransient
-{
-  NSArray<ENRMFormattingRange *> *transient = [_detectorPipeline allTransientFormattingRanges];
-  if (transient.count == 0) {
-    return _formattingStore.allRanges;
+  NSString *plainText = ENRMGetPlainText(_textView);
+  NSRange selection = _textView.selectedRange;
+  if (NSMaxRange(selection) > plainText.length) {
+    return;
   }
-  NSMutableArray<ENRMFormattingRange *> *merged = [_formattingStore.allRanges mutableCopy];
-  [merged addObjectsFromArray:transient];
-  return merged;
+
+  // 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 onto the chip's line.
+  BOOL needsLeadingBreak =
+      displayMode && selection.location > 0 && [plainText characterAtIndex:selection.location - 1] != '\n';
+  NSUInteger afterSelection = NSMaxRange(selection);
+  BOOL needsTrailingBreak =
+      displayMode && afterSelection < plainText.length && [plainText characterAtIndex:afterSelection] != '\n';
+
+  NSString *prefix = needsLeadingBreak ? @"\n" : @"";
+  NSString *suffix = needsTrailingBreak ? @"\n" : @"";
+  NSString *replacement = [NSString stringWithFormat:@"%@%@%@", prefix, ENRMObjectReplacementString(), suffix];
+  NSUInteger chipPosition = selection.location + prefix.length;
+
+  // Plain text first, chip second. Going through replaceTextInRange: is what gets
+  // the formatting store, the block store, orphaned-anchor pruning and the
+  // detectors adjusted for the edit; stamping the attachment afterwards only adds
+  // an attribute, so none of that bookkeeping sees a second edit.
+  [self replaceTextInRange:selection withText:replacement formattingRanges:@[]];
+
+  ENRMMathAtom *atom = [[ENRMMathAtom alloc] init];
+  atom.position = chipPosition;
+  atom.latex = latex;
+  atom.displayMode = displayMode;
+  [_mathChipController applyAtoms:@[ atom ] offset:0];
+
+  NSUInteger caret = selection.location + replacement.length;
+  _textView.selectedRange = NSMakeRange(MIN(caret, ENRMGetPlainText(_textView).length), 0);
+
+  // replaceTextInRange: already emitted text/selection/formatting for the edit, but
+  // the caret moved after it and the chip attribute changed the measured height.
+  [_inputEventEmitter emitOnChangeSelection];
+  [self requestHeightUpdate];
+  [self scheduleRelayoutIfNeeded];
 }
 
-- (void)clearActiveMention:(nullable NSString *)indicatorOverride
+- (void)updateMath:(NSInteger)start latex:(NSString *)latex displayMode:(BOOL)displayMode
 {
-  NSString *indicator = indicatorOverride ?: _activeMentionIndicator;
-  _activeMentionIndicator = nil;
-  _activeMentionRange = NSMakeRange(NSNotFound, 0);
-  _activeMentionText = @"";
+  if (start < 0) {
+    return;
+  }
+  // Formula and mode live on the attachment, so this changes no text: no store
+  // adjustment and no edit phase are needed, only a re-render and a re-measure.
+  if (![_mathChipController updateChipAtPosition:(NSUInteger)start latex:latex displayMode:displayMode]) {
+    return;
+  }
 
-  if (indicator.length > 0) {
-    [self emitOnEndMention:indicator];
+  // Gated like every other producer: `emitOnChangeMarkdown` is not self-guarding
+  // (the check lives at each call site, e.g. `emitFormattingChanged`), and it
+  // serializes the whole document — firing it for an app that never set
+  // `onChangeMarkdown` would be pure cost. Android gates the same way.
+  if (_inputEventEmitter.emitMarkdown) {
+    [_inputEventEmitter emitOnChangeMarkdown];
   }
+  [self requestHeightUpdate];
+  [self scheduleRelayoutIfNeeded];
 }
 
-- (nullable ENRMInputMentionCandidate *)mentionCandidateAtCursor
+- (void)removeMath:(NSInteger)start
 {
-  NSRange selectedRange = _textView.selectedRange;
-  if (_mentionIndicators.count == 0 || selectedRange.length != 0) {
-    return nil;
-  }
-
-  NSString *plainText = ENRMGetPlainText(_textView);
-  NSUInteger cursor = selectedRange.location;
-  if (cursor > plainText.length) {
-    return nil;
+  if (start < 0 || [_mathChipController atomAtPosition:(NSUInteger)start] == nil) {
+    return;
   }
 
-  NSUInteger start = [ENRMWordsUtils tokenStartInText:plainText beforePosition:cursor];
-  NSString *token = [plainText substringWithRange:NSMakeRange(start, cursor - start)];
-  NSString *matchedIndicator = nil;
-  for (NSString *indicator in _mentionIndicators) {
-    if ([token hasPrefix:indicator]) {
-      matchedIndicator = indicator;
-      break;
-    }
-  }
-  if (matchedIndicator == nil) {
-    return nil;
-  }
+  // Deleting the character takes the attachment and its paragraph style with it,
+  // so the ordinary text path is enough — no controller-side cleanup like Android
+  // needs for its separate AlignmentSpan, and replaceTextInRange: already emits
+  // the events and re-requests the height.
+  [self replaceTextInRange:NSMakeRange((NSUInteger)start, 1) withText:@"" formattingRanges:@[]];
 
-  if ([_formattingStore rangeOfType:ENRMInputStyleTypeLink containingPosition:start] != nil) {
-    return nil;
+  if (_activeMathChipPosition == (NSUInteger)start) {
+    _activeMathChipPosition = NSNotFound;
   }
+}
 
-  return [ENRMInputMentionCandidate candidateWithIndicator:matchedIndicator
-                                                     start:start
-                                                       end:cursor
-                                                      text:[token substringFromIndex:matchedIndicator.length]];
+/// Chips in document order, as plain data for the serializer. Every path that
+/// serializes the live buffer must pass this, or each formula leaves the editor as
+/// a bare placeholder character instead of `$latex$`.
+- (NSArray<ENRMMathAtom *> *)mathAtomsForSerialization
+{
+  return [_mathChipController allAtoms];
 }
 
-- (void)updateActiveMention
+#if !TARGET_OS_OSX
+
+- (void)handleMathChipTap:(UITapGestureRecognizer *)gesture
 {
-  ENRMInputMentionCandidate *candidate = [self mentionCandidateAtCursor];
-  if (candidate == nil) {
-    [self clearActiveMention:nil];
+  if (gesture.state != UIGestureRecognizerStateRecognized) {
+    return;
+  }
+  CGPoint location = [gesture locationInView:_textView];
+  NSUInteger chipPosition = [_mathChipController chipPositionAtPoint:location];
+  if (chipPosition == NSNotFound) {
+    return;
+  }
+  ENRMMathAtom *atom = [_mathChipController atomAtPosition:chipPosition];
+  if (atom == nil) {
     return;
   }
 
-  NSString *indicator = candidate.indicator;
-  NSUInteger start = candidate.start;
-  NSUInteger end = candidate.end;
-  NSString *query = candidate.text;
+  [_mathChipController clearSelectionsExceptPosition:chipPosition];
+  [_mathChipController setSelected:YES atPosition:chipPosition];
 
-  if (_activeMentionIndicator == nil || ![_activeMentionIndicator isEqualToString:indicator] ||
-      _activeMentionRange.location != start) {
-    if (_activeMentionIndicator != nil) {
-      [self emitOnEndMention:_activeMentionIndicator];
-    }
-    _activeMentionIndicator = indicator;
-    [self emitOnStartMention:indicator];
-  }
-  _activeMentionRange = NSMakeRange(start, end - start);
+  // Set before moving the caret: textViewDidChangeSelection: reads both to decide
+  // whether the highlight it is about to clear was set by this very tap.
+  _activeMathChipPosition = chipPosition;
+  _suppressMathChipClearOnce = YES;
+  // Caret after the chip, not a length-1 selection: a selection would draw the
+  // system's blue range handles on top of the chip's own selected styling.
+  NSUInteger caret = MIN(chipPosition + 1, ENRMGetPlainText(_textView).length);
+  _textView.selectedRange = NSMakeRange(caret, 0);
 
-  if (![_activeMentionText isEqualToString:query]) {
-    _activeMentionText = query;
-    [self emitOnChangeMentionWithIndicator:indicator text:query];
-  }
+  // Recomputed rather than reused from the hit-test: selecting the chip
+  // invalidated its layout above.
+  CGRect glyphRect = [_mathChipController chipRectAtPosition:chipPosition];
+  CGRect rectInSelf =
+      CGRectIsNull(glyphRect) ? CGRectZero : [self.contentView convertRect:glyphRect fromView:_textView];
+
+  [_inputEventEmitter emitOnMathPressWithLatex:atom.latex
+                                         range:NSMakeRange(chipPosition, 1)
+                                   displayMode:atom.displayMode
+                                          rect:rectInSelf];
 }
 
-- (BOOL)deleteLinkForReplacementRange:(NSRange)range replacementText:(NSString *)text
+#endif
+
+#pragma mark -
+
+- (void)showLinkPrompt
 {
-  if (text.length > 0) {
-    return NO;
-  }
+  ENRMFormattingRange *activeLink = [_linkCoordinator linkAtPosition:_textView.selectedRange.location];
+  NSString *existingURL = activeLink != nil ? activeLink.url : nil;
 
-  NSUInteger lookupPosition;
-  if (range.length > 0) {
-    lookupPosition = range.location;
-  } else if (range.location > 0) {
-    lookupPosition = range.location - 1;
-  } else {
-    return NO;
-  }
+  __weak EnrichedMarkdownTextInput *weakSelf = self;
+  ENRMShowLinkPrompt(self, existingURL, ^(NSString *url) { [weakSelf setLink:url]; });
+}
 
-  ENRMFormattingRange *linkRange = [_formattingStore rangeOfType:ENRMInputStyleTypeLink
-                                              containingPosition:lookupPosition];
-  if (linkRange == nil) {
-    return NO;
-  }
+/// Serializes plain text with inline + block formatting, resolving each block's
+/// markdown line prefix through its registered handler. With no block handlers
+/// registered the prefix provider is never consulted productively and output
+/// equals the inline-only serialization.
+- (NSString *)serializeText:(NSString *)text
+                     ranges:(NSArray<ENRMFormattingRange *> *)ranges
+                blockRanges:(NSArray<ENRMBlockRange *> *)blockRanges
+{
+  return [_clipboardCoordinator serializeText:text
+                                    mathAtoms:[self mathAtomsForSerialization]
+                                       ranges:ranges
+                                  blockRanges:blockRanges];
+}
 
-  [self replaceTextInRange:linkRange.range withText:@"" formattingRanges:@[]];
-  [self clearActiveMention:nil];
-  return YES;
+- (nullable NSString *)markdownForSelectedRange
+{
+  return [_clipboardCoordinator serializeSelectedRange:_textView.selectedRange
+                                                inText:ENRMGetPlainText(_textView)
+                                             mathAtoms:[self mathAtomsForSerialization]];
 }
 
-- (void)emitOnChangeText
+- (void)copyToClipboard
 {
-  auto emitter = [self getEventEmitter];
-  if (emitter == nullptr) {
+  NSString *plainText = ENRMGetPlainText(_textView);
+  if (plainText.length == 0) {
     return;
   }
-  NSString *plainText = ENRMGetPlainText(_textView);
-  emitter->onChangeText({.value = std::string([plainText UTF8String] ?: "")});
+  NSString *markdown = [_clipboardCoordinator serializeFullDocument:plainText
+                                                          mathAtoms:[self mathAtomsForSerialization]];
+  NSMutableDictionary *items = [NSMutableDictionary dictionary];
+  items[kUTIPlainText] = plainText;
+  if (markdown.length > 0) {
+    items[kENRMMarkdownPasteboardType] = markdown;
+  }
+  copyItemsToPasteboard(items);
 }
 
-- (void)emitOnChangeMarkdown
+- (void)requestMarkdown:(NSInteger)requestId
 {
-  auto emitter = [self getEventEmitter];
-  if (emitter == nullptr) {
-    return;
-  }
-  NSString *markdown = [ENRMMarkdownSerializer serializeAttributedString:_textView.textStorage
-                                                                  ranges:[self allRangesIncludingTransient]];
-  emitter->onChangeMarkdown({.value = std::string([markdown UTF8String] ?: "")});
+  [_inputEventEmitter requestMarkdown:requestId];
 }
 
-- (void)emitOnChangeSelection
+- (CGRect)computeCaretRect
 {
-  auto emitter = [self getEventEmitter];
-  if (emitter == nullptr) {
-    return;
+  CGRect caretRect = CGRectZero;
+#if !TARGET_OS_OSX
+  UITextRange *selectedRange = _textView.selectedTextRange;
+  if (selectedRange != nil) {
+    caretRect = [_textView caretRectForPosition:selectedRange.start];
   }
+#else
   NSRange selection = _textView.selectedRange;
-  emitter->onChangeSelection({
-      .start = static_cast<int>(selection.location),
-      .end = static_cast<int>(NSMaxRange(selection)),
-  });
+  if (selection.location != NSNotFound) {
+    NSRange glyphRange = [_textView.layoutManager glyphRangeForCharacterRange:NSMakeRange(selection.location, 0)
+                                                         actualCharacterRange:NULL];
+    caretRect = [_textView.layoutManager boundingRectForGlyphRange:glyphRange inTextContainer:_textView.textContainer];
+    caretRect.origin.x += _textView.textContainerInset.left;
+    caretRect.origin.y += _textView.textContainerInset.top;
+  }
+#endif
+  return caretRect;
 }
 
-- (void)emitOnChangeState
+- (void)requestCaretRect:(NSInteger)requestId
 {
-  auto emitter = [self getEventEmitter];
-  if (emitter == nullptr) {
-    return;
-  }
+  [_inputEventEmitter requestCaretRect:requestId];
+}
+
+- (void)handleCommand:(const NSString *)commandName args:(const NSArray *)args
+{
+  RCTEnrichedMarkdownTextInputHandleCommand(self, commandName, args);
+}
 
-  NSUInteger cursor = _textView.selectedRange.location;
-  BOOL boldActive = [self isEffectiveStyleActive:ENRMInputStyleTypeStrong atPosition:cursor];
-  BOOL italicActive = [self isEffectiveStyleActive:ENRMInputStyleTypeEmphasis atPosition:cursor];
-  BOOL underlineActive = [self isEffectiveStyleActive:ENRMInputStyleTypeUnderline atPosition:cursor];
-  BOOL strikethroughActive = [self isEffectiveStyleActive:ENRMInputStyleTypeStrikethrough atPosition:cursor];
-  BOOL spoilerActive = [self isEffectiveStyleActive:ENRMInputStyleTypeSpoiler atPosition:cursor];
-  BOOL linkActive = [self isEffectiveStyleActive:ENRMInputStyleTypeLink atPosition:cursor];
+#pragma mark - ENRMInputEventEmitterDataSource
 
-  if (_prevState.initialized && _prevState.bold == boldActive && _prevState.italic == italicActive &&
-      _prevState.underline == underlineActive && _prevState.strikethrough == strikethroughActive &&
-      _prevState.spoiler == spoilerActive && _prevState.link == linkActive) {
-    return;
+- (std::shared_ptr<EnrichedMarkdownTextInputEventEmitter const>)fabricEventEmitter
+{
+  if (_eventEmitter == nullptr || _editSession.shouldSuppressEvents) {
+    return nullptr;
   }
+  return std::static_pointer_cast<EnrichedMarkdownTextInputEventEmitter const>(_eventEmitter);
+}
 
-  _prevState.bold = boldActive;
-  _prevState.italic = italicActive;
-  _prevState.underline = underlineActive;
-  _prevState.strikethrough = strikethroughActive;
-  _prevState.spoiler = spoilerActive;
-  _prevState.link = linkActive;
-  _prevState.initialized = YES;
-
-  emitter->onChangeState({
-      .bold = {.isActive = boldActive},
-      .italic = {.isActive = italicActive},
-      .underline = {.isActive = underlineActive},
-      .strikethrough = {.isActive = strikethroughActive},
-      .spoiler = {.isActive = spoilerActive},
-      .link = {.isActive = linkActive},
-  });
+- (NSRange)selectedRange
+{
+  return _textView.selectedRange;
 }
 
-- (void)emitCaretRectChangeIfNeeded
+- (BOOL)isStyleActive:(ENRMInputStyleType)type inRange:(NSRange)range
 {
-  auto emitter = [self getEventEmitter];
-  if (emitter == nullptr) {
-    return;
-  }
+  return [_formattingStore isStyleActive:type inRange:range];
+}
 
-  CGRect caretRect = [self computeCaretRect];
+- (BOOL)isEffectiveStyleActive:(ENRMInputStyleType)type atPosition:(NSUInteger)position
+{
+  return [_typingController isEffectiveStyleActive:type atPosition:position];
+}
 
-  if (_prevCaretRect.has_value() && CGRectEqualToRect(_prevCaretRect.value(), caretRect)) {
-    return;
-  }
+#pragma mark - ENRMInputTypingAttributesDataSource
 
-  _prevCaretRect = caretRect;
+- (BOOL)isStyleAdjacentBefore:(ENRMInputStyleType)type position:(NSUInteger)position
+{
+  return [_formattingStore isStyleAdjacentBefore:type position:position];
+}
 
-  emitter->onCaretRectChange({
-      .x = caretRect.origin.x,
-      .y = caretRect.origin.y,
-      .width = caretRect.size.width,
-      .height = caretRect.size.height,
-  });
+- (BOOL)isStyleActive:(ENRMInputStyleType)type atPosition:(NSUInteger)position
+{
+  return [_formattingStore isStyleActive:type atPosition:position];
 }
 
-- (NSArray<NSString *> *)contextMenuItemTexts
+- (NSString *)currentMarkdown
 {
-  return _contextMenuItemTexts ?: @[];
+  return [self serializeText:ENRMGetPlainText(_textView)
+                      ranges:[self allRangesIncludingTransient]
+                 blockRanges:_blockStore.allRanges];
 }
 
-- (NSArray<NSString *> *)contextMenuItemIcons
+- (NSArray<ENRMFormattingRange *> *)allRangesIncludingTransient
 {
-  return _contextMenuItemIcons ?: @[];
+  return [_clipboardCoordinator allRangesIncludingTransient];
 }
 
-- (ENRMInputSelectionMenuConfig)inputSelectionMenuConfig
+- (void)updateActiveMention
 {
-  return _inputSelectionMenuConfig;
+  [self dispatchMentionUpdate];
 }
 
-- (ENRMFormatMenuConfig)formatMenuConfig
+- (void)clearActiveMention:(nullable NSString *)indicatorOverride
 {
-  return _formatMenuConfig;
+  [self dispatchMentionEvents:[_mentionCoordinator clearWithIndicatorOverride:indicatorOverride]];
 }
 
-- (void)emitContextMenuItemPress:(NSString *)itemText
+- (void)dispatchMentionUpdate
 {
-  auto eventEmitter = [self getEventEmitter];
-  if (eventEmitter == nullptr) {
-    return;
+  NSString *plainText = ENRMGetPlainText(_textView);
+  [self dispatchMentionEvents:[_mentionCoordinator updateWithText:plainText selectedRange:_textView.selectedRange]];
+}
+
+- (void)dispatchMentionEvents:(NSArray<ENRMMentionEvent *> *)events
+{
+  for (ENRMMentionEvent *event in events) {
+    switch (event.type) {
+      case ENRMMentionEventStart:
+        [_inputEventEmitter emitOnStartMention:event.indicator];
+        break;
+      case ENRMMentionEventChange:
+        [_inputEventEmitter emitOnChangeMentionWithIndicator:event.indicator text:event.text];
+        break;
+      case ENRMMentionEventEnd:
+        [_inputEventEmitter emitOnEndMention:event.indicator];
+        break;
+    }
   }
+}
 
-  NSRange selectedRange = _textView.selectedRange;
-  NSString *selectedText =
-      selectedRange.length > 0 ? [_textView.textStorage.string substringWithRange:selectedRange] : @"";
+- (BOOL)deleteLinkForReplacementRange:(NSRange)range replacementText:(NSString *)text
+{
+  if (text.length > 0) {
+    return NO;
+  }
 
-  auto isActive = [&](ENRMInputStyleType type) -> BOOL {
-    if (selectedRange.length > 0) {
-      return [_formattingStore isStyleActive:type inRange:selectedRange];
-    }
-    return [self isEffectiveStyleActive:type atPosition:selectedRange.location];
-  };
+  NSUInteger lookupPosition;
+  if (range.length > 0) {
+    lookupPosition = range.location;
+  } else if (range.location > 0) {
+    lookupPosition = range.location - 1;
+  } else {
+    return NO;
+  }
 
-  BOOL boldActive = isActive(ENRMInputStyleTypeStrong);
-  BOOL italicActive = isActive(ENRMInputStyleTypeEmphasis);
-  BOOL underlineActive = isActive(ENRMInputStyleTypeUnderline);
-  BOOL strikethroughActive = isActive(ENRMInputStyleTypeStrikethrough);
-  BOOL spoilerActive = isActive(ENRMInputStyleTypeSpoiler);
-  BOOL linkActive = isActive(ENRMInputStyleTypeLink);
-
-  eventEmitter->onContextMenuItemPress({
-      .itemText = std::string(itemText.UTF8String),
-      .selectedText = std::string(selectedText.UTF8String),
-      .selectionStart = static_cast<int>(selectedRange.location),
-      .selectionEnd = static_cast<int>(NSMaxRange(selectedRange)),
-      .styleState =
-          {
-              .bold = {.isActive = boldActive},
-              .italic = {.isActive = italicActive},
-              .underline = {.isActive = underlineActive},
-              .strikethrough = {.isActive = strikethroughActive},
-              .spoiler = {.isActive = spoilerActive},
-              .link = {.isActive = linkActive},
-          },
-  });
+  ENRMFormattingRange *linkRange = [_linkCoordinator linkAtPosition:lookupPosition];
+  if (linkRange == nil) {
+    return NO;
+  }
+
+  [self replaceTextInRange:linkRange.range withText:@"" formattingRanges:@[]];
+  [self clearActiveMention:nil];
+  return YES;
 }
 
-- (void)emitOnFocus
+- (NSArray<NSString *> *)contextMenuItemTexts
 {
-  auto emitter = [self getEventEmitter];
-  if (emitter == nullptr) {
-    return;
-  }
-  emitter->onInputFocus({});
+  return _contextMenuItemTexts ?: @[];
 }
 
-- (void)emitOnBlur
+- (NSArray<NSString *> *)contextMenuItemIcons
 {
-  auto emitter = [self getEventEmitter];
-  if (emitter == nullptr) {
-    return;
-  }
-  emitter->onInputBlur({});
+  return _contextMenuItemIcons ?: @[];
 }
 
-- (void)emitOnLinkDetectedWithText:(NSString *)text url:(NSString *)url range:(NSRange)range
+- (ENRMInputSelectionMenuConfig)inputSelectionMenuConfig
 {
-  auto emitter = [self getEventEmitter];
-  if (emitter == nullptr) {
-    return;
-  }
-  emitter->onLinkDetected({
-      .text = std::string([text UTF8String] ?: ""),
-      .url = std::string([url UTF8String] ?: ""),
-      .start = static_cast<int>(range.location),
-      .end = static_cast<int>(range.location + range.length),
-  });
+  return _inputSelectionMenuConfig;
 }
 
-- (void)emitOnStartMention:(NSString *)indicator
+- (ENRMFormatMenuConfig)formatMenuConfig
 {
-  auto emitter = [self getEventEmitter];
-  if (emitter == nullptr) {
-    return;
-  }
-  emitter->onStartMention({.indicator = std::string([indicator UTF8String] ?: "")});
+  return _formatMenuConfig;
 }
 
-- (void)emitOnChangeMentionWithIndicator:(NSString *)indicator text:(NSString *)text
+- (ENRMInputEventEmitter *)inputEventEmitter
 {
-  auto emitter = [self getEventEmitter];
-  if (emitter == nullptr) {
-    return;
-  }
-  emitter->onChangeMention({
-      .indicator = std::string([indicator UTF8String] ?: ""),
-      .text = std::string([text UTF8String] ?: ""),
-  });
+  return _inputEventEmitter;
 }
 
-- (void)emitOnEndMention:(NSString *)indicator
+- (ENRMInputTypingAttributesController *)typingController
 {
-  auto emitter = [self getEventEmitter];
-  if (emitter == nullptr) {
-    return;
-  }
-  emitter->onEndMention({.indicator = std::string([indicator UTF8String] ?: "")});
+  return _typingController;
 }
 
 #pragma mark - Text edit tracking
 
 - (void)handleTextChanged
 {
-  if (ENRMHasMarkedText(_textView)) {
+  if (_editSession.isComposing) {
     return;
   }
 
@@ -1824,64 +1867,63 @@ using namespace facebook::react;
     }
   }
 
-  [_formattingStore adjustForEditAtLocation:editLocation deletedLength:deletedLength insertedLength:insertedLength];
+  ENRMEditContext *context = [[ENRMEditContext alloc] initWithEditLocation:editLocation
+                                                             deletedLength:deletedLength
+                                                            insertedLength:insertedLength
+                                                    preEditReplacedNewline:_preEditReplacedNewline
+                                                          preEditBlockType:_preEditBlockType
+                                                         preEditBlockLevel:_preEditBlockLevel
+                                                  preEditParagraphWasEmpty:_preEditParagraphWasEmpty
+                                                             pendingStyles:_typingController.pendingStyles
+                                                      pendingStyleRemovals:_typingController.pendingStyleRemovals];
 
-  if (insertedLength > 0) {
-    NSRange insertedRange = NSMakeRange(editLocation, insertedLength);
-
-    // Skip applying pending styles when the insertion is only line breaks —
-    // a phantom range over a bare newline corrupts isStyleActive() at the boundary.
-    NSString *plainText = ENRMGetPlainText(_textView);
-    NSUInteger insertedEnd = NSMaxRange(insertedRange);
-    BOOL insertedHasGlyphContent = NO;
-    if (insertedEnd <= plainText.length) {
-      NSCharacterSet *newlines = [NSCharacterSet newlineCharacterSet];
-      for (NSUInteger i = insertedRange.location; i < insertedEnd; i++) {
-        if (![newlines characterIsMember:[plainText characterAtIndex:i]]) {
-          insertedHasGlyphContent = YES;
-          break;
-        }
-      }
-    }
-
-    if (insertedHasGlyphContent) {
-      for (NSNumber *styleNum in _pendingStyles) {
-        ENRMFormattingRange *newRange = [ENRMFormattingRange rangeWithType:(ENRMInputStyleType)styleNum.integerValue
-                                                                     range:insertedRange];
-        [_formattingStore addRange:newRange];
-      }
-    }
+  BOOL touchedNewline = [_editPipeline processTextChangeWithContext:context];
 
-    // adjustForEditAtLocation may have expanded an existing range to cover
-    // the insertion — carve out the inserted portion for removed styles.
-    for (NSNumber *styleNum in _pendingStyleRemovals) {
-      [_formattingStore removeType:(ENRMInputStyleType)styleNum.integerValue inRange:insertedRange];
-    }
-  }
+  // Consumed: clear pre-edit state so stale values can't leak to the next edit.
+  _preEditBlockType = ENRMInputBlockTypeParagraph;
+  _preEditBlockLevel = 0;
+  _preEditParagraphWasEmpty = NO;
+  _preEditReplacedNewline = NO;
 
   _lastTextLength = newLength;
 
 #if !TARGET_OS_OSX
   if (newLength == 0) {
-    [self resetBaseTypingAttributes];
+    if ([self headingLevelForCursorParagraph] > 0 || [self listBlockForCursorParagraph] != nil) {
+      [_typingController syncWithCursorBlock];
+    } else {
+      [self resetBaseTypingAttributes];
+    }
   }
 #endif
 
-  [self applyFormatting];
+  if (touchedNewline) {
+    [self applyFormatting];
+  } else {
+    [self applyFormattingScopedToEditAtLocation:editLocation insertedLength:insertedLength];
+  }
+
+  if (_textView.selectedRange.length == 0) {
+    [_typingController syncWithCursorBlock];
+  }
 
-  NSUInteger clampedEditLocation = MIN(editLocation, newLength);
-  NSUInteger clampedInsertedLength = MIN(insertedLength, newLength - clampedEditLocation);
-  [_detectorPipeline processTextChange:ENRMGetPlainText(_textView)
-                     modificationRange:NSMakeRange(clampedEditLocation, clampedInsertedLength)];
+  if ([self listBlockForCursorParagraph] != nil) {
+    [_typingController syncWithCursorBlock];
+  } else if (_textView.typingAttributes[NSParagraphStyleAttributeName] != nil) {
+    [_typingController clearListParagraphStyle];
+  }
+
+  [_editPipeline detectLinksAtLocation:editLocation insertedLength:insertedLength];
 
   [self updatePlaceholderVisibility];
-  [self emitOnChangeText];
-  [self emitOnChangeSelection];
-  [self emitFormattingChanged];
+  [_inputEventEmitter emitOnChangeText];
+  [_inputEventEmitter emitOnChangeSelection];
+  [_inputEventEmitter emitFormattingChanged];
   [self updateActiveMention];
-  [self emitCaretRectChangeIfNeeded];
+  [_inputEventEmitter emitCaretRectChangeIfNeeded];
   [self requestHeightUpdate];
   [self scheduleRelayoutIfNeeded];
+  [self updateEmptyBulletMarker];
 }
 
 #pragma mark - Text view delegate
@@ -1919,17 +1961,21 @@ using namespace facebook::react;
 {
   [self stripLinkTypingAttributes];
 
-  if (_textView.selectedRange.length == 0 && !_isTextChanging) {
+  if (_textView.selectedRange.length == 0 && _editSession.phase == ENRMEditPhaseIdle) {
     NSString *text = ENRMGetPlainText(_textView);
     if (text.length > 0) {
       NSRange paragraphRange = [text paragraphRangeForRange:_textView.selectedRange];
       NSString *paragraphText = [text substringWithRange:paragraphRange];
       BOOL isEmpty = paragraphText.length == 0 || [paragraphText isEqualToString:@"\n"];
       if (isEmpty) {
-        NSMutableDictionary *attrs = [NSMutableDictionary dictionary];
-        attrs[NSFontAttributeName] = _formatterStyle.baseFont;
-        attrs[NSForegroundColorAttributeName] = _formatterStyle.baseTextColor;
-        _textView.typingAttributes = attrs;
+        if ([self headingLevelForCursorParagraph] > 0 || [self listBlockForCursorParagraph] != nil) {
+          [_typingController syncWithCursorBlock];
+        } else {
+          NSMutableDictionary *attrs = [NSMutableDictionary dictionary];
+          attrs[NSFontAttributeName] = _formatterStyle.baseFont;
+          attrs[NSForegroundColorAttributeName] = _formatterStyle.baseTextColor;
+          _textView.typingAttributes = attrs;
+        }
       }
     }
   }
@@ -1937,125 +1983,154 @@ using namespace facebook::react;
 
 - (BOOL)textView:(UITextView *)textView shouldChangeTextInRange:(NSRange)range replacementText:(NSString *)text
 {
+  [_inputEventEmitter emitOnKeyPress:text];
   if ([self deleteLinkForReplacementRange:range replacementText:text]) {
     return NO;
   }
+  if ([self handleListKeyForReplacementRange:range replacementText:text]) {
+    return NO;
+  }
   _preEditSelectedRange = _lastSelectedRange;
-  _isTextChanging = YES;
+  [self capturePreEditBlockForRange:range];
+  _preEditParagraphWasEmpty = [self preEditParagraphWasEmpty:range];
+  _preEditReplacedNewline = [self replacedRangeTouchesNewline:range];
+  [_editSession enterPhase:ENRMEditPhaseProcessing];
   [self stripLinkTypingAttributes];
   return YES;
 }
 
 - (void)textViewDidChange:(UITextView *)textView
 {
-  if (_isApplyingFormatting) {
+  if (_editSession.shouldSuppressFormatting) {
     return;
   }
   [self handleTextChanged];
-  _isTextChanging = NO;
-  _lastTextChangeTime = CACurrentMediaTime();
+  [_editSession exitPhase];
+  [_editSession recordTextChange];
   _lastSelectedRange = textView.selectedRange;
 }
 
 - (void)textViewDidBeginEditing:(UITextView *)textView
 {
-  [self emitOnFocus];
+  [_inputEventEmitter emitOnFocus];
 }
 
 - (void)textViewDidEndEditing:(UITextView *)textView
 {
   [self clearActiveMention:nil];
-  [self emitOnBlur];
+  [_inputEventEmitter emitOnBlur];
+}
+
+/// Atomic-link snap clamped to the current text length, so a stale link range
+/// past the text end can't drive an unbounded snap/clamp loop.
+- (NSRange)clampedAtomicSelectionForSelection:(NSRange)selection
+{
+  NSRange adjusted = [_formattingStore selectionAdjustedForAtomicLinks:selection];
+  NSUInteger textLength = _textView.textStorage.length;
+  if (adjusted.location > textLength) {
+    return NSMakeRange(textLength, 0);
+  }
+  if (NSMaxRange(adjusted) > textLength) {
+    adjusted.length = textLength - adjusted.location;
+  }
+  return adjusted;
+}
+
+/// YES while a UIKit selection gesture (handle drag, long-press loupe) is
+/// mid-flight; snapping selectedRange then fights the gesture and flickers the
+/// edit menu, so callers defer the snap until it settles.
+- (BOOL)selectionGestureIsActive
+{
+  for (UIGestureRecognizer *recognizer in _textView.gestureRecognizers) {
+    if (recognizer.state == UIGestureRecognizerStateBegan || recognizer.state == UIGestureRecognizerStateChanged) {
+      return YES;
+    }
+  }
+  return NO;
+}
+
+/// Re-applies the atomic-link snap once the selection gesture ends, polling the
+/// main queue because UIKit may not re-fire the selection delegate at touch-up.
+- (void)schedulePostGestureAtomicSnap
+{
+  if (_atomicSnapScheduled) {
+    return;
+  }
+  _atomicSnapScheduled = YES;
+  __weak __typeof(self) weakSelf = self;
+  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(kENRMAtomicSnapPollInterval * NSEC_PER_SEC)),
+                 dispatch_get_main_queue(), ^{
+                   __typeof(self) strongSelf = weakSelf;
+                   if (strongSelf == nil) {
+                     return;
+                   }
+                   strongSelf->_atomicSnapScheduled = NO;
+                   if (strongSelf->_editSession.shouldSuppressSelectionSideEffects ||
+                       strongSelf->_editSession.isComposing) {
+                     return;
+                   }
+                   if ([strongSelf selectionGestureIsActive]) {
+                     [strongSelf schedulePostGestureAtomicSnap];
+                     return;
+                   }
+                   NSRange selection = strongSelf->_textView.selectedRange;
+                   NSRange adjusted = [strongSelf clampedAtomicSelectionForSelection:selection];
+                   if (!NSEqualRanges(adjusted, selection)) {
+                     strongSelf->_textView.selectedRange = adjusted;
+                   }
+                 });
 }
 
 - (void)textViewDidChangeSelection:(UITextView *)textView
 {
   NSRange newSelection = textView.selectedRange;
-  // Links (e.g. mentions) are atomic: snap a partial selection to the whole link, and a caret inside
-  // a link to its end. Returning hands the adjusted selection to the recursive change (no double emit).
-  if (!_isApplyingFormatting && !_isTextChanging && !ENRMHasMarkedText(_textView)) {
-    NSRange adjusted = [_formattingStore selectionAdjustedForAtomicLinks:newSelection];
-    if (!NSEqualRanges(adjusted, newSelection)) {
-      _textView.selectedRange = adjusted;
-      return;
+  if (!_editSession.shouldSuppressSelectionSideEffects && !_editSession.isComposing) {
+    if ([self selectionGestureIsActive]) {
+      [self schedulePostGestureAtomicSnap];
+    } else {
+      NSRange adjusted = [self clampedAtomicSelectionForSelection:newSelection];
+      if (!NSEqualRanges(adjusted, newSelection)) {
+        _textView.selectedRange = adjusted;
+        return;
+      }
     }
   }
   NSRange previousSelection = _lastSelectedRange;
   _lastSelectedRange = newSelection;
 
-  if (_isApplyingFormatting || _isTextChanging) {
+  if (_editSession.shouldSuppressSelectionSideEffects) {
     return;
   }
 
-  if (ENRMHasMarkedText(_textView)) {
+  if (_editSession.isComposing) {
     return;
   }
 
-#if ENRICHED_MARKDOWN_MATH
+  BOOL selectionMoved =
+      newSelection.location != previousSelection.location || newSelection.length != previousSelection.length;
+
   if (_suppressMathChipClearOnce) {
-    // Caret update was triggered by handleTapForMathChip — keep that chip
-    // selected; consume the suppression flag.
+    // This caret move is the one handleMathChipTap: just made — keep its chip
+    // highlighted and consume the suppression.
     _suppressMathChipClearOnce = NO;
-  } else {
-    [self clearMathChipSelectionsExcept:NSMakeRange(NSNotFound, 0)];
-    _activeMathChipIndex = NSNotFound;
+  } else if (_activeMathChipPosition != NSNotFound) {
+    [_mathChipController clearSelectionsExceptPosition:NSNotFound];
+    _activeMathChipPosition = NSNotFound;
   }
-#endif
-
-  BOOL selectionMoved =
-      newSelection.location != previousSelection.location || newSelection.length != previousSelection.length;
 
   if (selectionMoved) {
-    [self resetPendingStylesForSelectionChange];
+    [_typingController resetForSelectionChange];
   }
 
   [self manageSelectionBasedChanges];
 
-  [self emitOnChangeSelection];
+  [_inputEventEmitter emitOnChangeSelection];
   [self updateActiveMention];
-  [self emitOnChangeState];
-  [self emitCaretRectChangeIfNeeded];
+  [_inputEventEmitter emitOnChangeState];
+  [_inputEventEmitter emitCaretRectChangeIfNeeded];
+  [self updateEmptyBulletMarker];
 }
 
-#if ENRICHED_MARKDOWN_MATH && !TARGET_OS_OSX
-- (void)clearMathChipSelectionsExcept:(NSRange)keepRange
-{
-  NSTextStorage *storage = _textView.textStorage;
-  if (storage.length == 0)
-    return;
-  __block BOOL anyChanged = NO;
-  __block NSMutableArray<NSValue *> *invalidationRanges = [NSMutableArray array];
-  [storage enumerateAttribute:NSAttachmentAttributeName
-                      inRange:NSMakeRange(0, storage.length)
-                      options:0
-                   usingBlock:^(id value, NSRange range, BOOL *stop) {
-                     if (![value isKindOfClass:[ENRMMathInlineAttachment class]])
-                       return;
-                     ENRMMathInlineAttachment *att = value;
-                     BOOL keep = NSEqualRanges(range, keepRange);
-                     if (att.isSelected && !keep) {
-                       att.isSelected = NO;
-                       [att invalidateRender];
-                       [invalidationRanges addObject:[NSValue valueWithRange:range]];
-                       anyChanged = YES;
-                     }
-                   }];
-  if (anyChanged) {
-    NSLayoutManager *lm = storage.layoutManagers.firstObject;
-    for (NSValue *v in invalidationRanges) {
-      NSRange r = v.rangeValue;
-      [lm invalidateLayoutForCharacterRange:r actualCharacterRange:NULL];
-    }
-    ENRMSetNeedsDisplay(_textView);
-  }
-}
-#else
-- (void)clearMathChipSelectionsExcept:(NSRange)keepRange
-{
-  (void)keepRange;
-}
-#endif
-
 #else
 
 #pragma mark - RCTBackedTextInputDelegate (macOS)
@@ -2067,7 +2142,7 @@ using namespace facebook::react;
 
 - (void)textInputDidBeginEditing
 {
-  [self emitOnFocus];
+  [_inputEventEmitter emitOnFocus];
 }
 
 - (BOOL)textInputShouldEndEditing
@@ -2078,7 +2153,7 @@ using namespace facebook::react;
 - (void)textInputDidEndEditing
 {
   [self clearActiveMention:nil];
-  [self emitOnBlur];
+  [_inputEventEmitter emitOnBlur];
 }
 
 - (BOOL)textInputShouldReturn
@@ -2097,31 +2172,36 @@ using namespace facebook::react;
 
 - (nullable NSString *)textInputShouldChangeText:(NSString *)text inRange:(NSRange)range
 {
+  [_inputEventEmitter emitOnKeyPress:text];
   if ([self deleteLinkForReplacementRange:range replacementText:text]) {
     return nil;
   }
   _preEditSelectedRange = _lastSelectedRange;
-  _isTextChanging = YES;
+  // Capture the same pre-edit block state the iOS path does — otherwise these
+  // ivars carry stale values from a previous edit into reconcileBlockContinuation.
+  [self capturePreEditBlockForRange:range];
+  _preEditParagraphWasEmpty = [self preEditParagraphWasEmpty:range];
+  _preEditReplacedNewline = [self replacedRangeTouchesNewline:range];
+  [_editSession enterPhase:ENRMEditPhaseProcessing];
   return text;
 }
 
 - (void)textInputDidChange
 {
-  if (_isApplyingFormatting) {
-    _isTextChanging = NO;
+  if (_editSession.shouldSuppressFormatting) {
+    [_editSession exitPhase];
     return;
   }
   [self handleTextChanged];
-  _isTextChanging = NO;
-  _lastTextChangeTime = CACurrentMediaTime();
+  [_editSession exitPhase];
+  [_editSession recordTextChange];
   _lastSelectedRange = _textView.selectedRange;
 }
 
 - (void)textInputDidChangeSelection
 {
   NSRange newSelection = _textView.selectedRange;
-  // Atomic link snapping — same logic as textViewDidChangeSelection: (iOS).
-  if (!_isApplyingFormatting && !_isTextChanging && !ENRMHasMarkedText(_textView)) {
+  if (!_editSession.shouldSuppressSelectionSideEffects && !_editSession.isComposing) {
     NSRange adjusted = [_formattingStore selectionAdjustedForAtomicLinks:newSelection];
     if (!NSEqualRanges(adjusted, newSelection)) {
       _textView.selectedRange = adjusted;
@@ -2131,11 +2211,11 @@ using namespace facebook::react;
   NSRange previousSelection = _lastSelectedRange;
   _lastSelectedRange = newSelection;
 
-  if (_isApplyingFormatting || _isTextChanging) {
+  if (_editSession.shouldSuppressSelectionSideEffects) {
     return;
   }
 
-  if (ENRMHasMarkedText(_textView)) {
+  if (_editSession.isComposing) {
     return;
   }
 
@@ -2143,13 +2223,13 @@ using namespace facebook::react;
       newSelection.location != previousSelection.location || newSelection.length != previousSelection.length;
 
   if (selectionMoved) {
-    [self resetPendingStylesForSelectionChange];
+    [_typingController resetForSelectionChange];
   }
 
-  [self emitOnChangeSelection];
+  [_inputEventEmitter emitOnChangeSelection];
   [self updateActiveMention];
-  [self emitOnChangeState];
-  [self emitCaretRectChangeIfNeeded];
+  [_inputEventEmitter emitOnChangeState];
+  [_inputEventEmitter emitCaretRectChangeIfNeeded];
 }
 
 // @required stubs for RCTBackedTextInputDelegate — RCTUITextView's internal adapter